SyntheticMDProductions/AI_Development_Automation_Manager

ADAM — AI Development and Automation Manager

ADAM is a local desktop command center for AI experiments: describe an idea, prepare and review a dataset, approve a training plan, generate samples, and use saved experiment history to decide what to try next.

It began as a Jarvis-inspired assistant for AI workflows and has grown into a Windows/PySide6 application with registered tools, model plugins, background jobs, live previews, and optional local Ollama chat and Remote access.

Source release: 1 October 2026 · 322 tests passed across 33 modules. This repository contains the desktop application and its source code. Model weights, personal datasets, saved jobs, and connected external trainer projects are supplied separately by the user.

Explore the interactive ADAM field guide — click the workflow stages, reviewers and model architectures, then explore four animated explanations of image construction. You can also download the standalone HTML guide and the visual map. The animations explain mechanisms; they are not model inference or quality benchmarks.

What ADAM includes

Workspace	What it does
Command center	Local Ollama chat, validated workflow planning, guided model creation, and sequential model batches
Training Studio / Dataset Lab	Dataset browsing, captions, keep/reject decisions, EVE proposals, recoverable exclusions, checkpoint review, and recipes
Jobs / History	Approval, scheduling, progress, previews, pause/cancel, retry, and persistent records
Generations / Showcase Video	Reproducible image batches, saved settings, generation history, and DDPM/Flow showcase MP4s
Video LoRA	Wan 2.1 T2V 1.3B clip preparation, character-reference suggestions, reviewed caption drafts, training, and video generation
Model Intelligence / Experiments	Training and generation evidence, run comparison, and follow-up experiment suggestions
Oasis player	Playable inference for compatible action-conditioned world models
Tools / Remote / System	Declared plugin settings, connected tool folders, optional authenticated device access, and hardware telemetry

Model family	Integration
DDPM, regular Flow Matching, SDXL LoRA	Adapters for separately connected local trainers and generators
PixelRow	Experimental built-in model that generates top to bottom, one row at a time
INRFlow	Experimental built-in coordinate-to-RGB flow model without a pretrained image compressor
Neural Cellular Automata	Included experimental custom plugin that learns image growth from a living seed
Oasis	Experimental connected action world model with temporal latent and temporal pixel-flow workflows
Wan video LoRA	Dedicated workspace and adapter for a connected LoRAVideoTrainer/Musubi environment

See release notes for changes since the September 5 release, and Oasis / INRFlow for integration details. Experimental architectures are intended for local exploration; this release makes no benchmark-quality claims.

Quick start

Download the complete source ZIP, extract it, or clone this repository, then run:

python -m pip install -r requirements.txt
python main.py

Use Python 3.10+ on Windows. You can also double-click Launch ADAM.bat after installing the requirements. Choose a CUDA-compatible PyTorch build for GPU training according to your hardware. Optional trainer projects keep their own dependencies and model weights; connect them in Settings → Tool folders. Ollama is optional for local chat and model-assisted planning. Chrome is needed for the visible image collector; FFmpeg is needed for video collection and splitting.

The release starts with empty tool connections and Remote access disabled. Application state is saved locally under data/, logs/, and config/settings.json.

Dataset preparation, captioning, and preview placeholders remain clearly marked as demo tools. The connected Dataset Collector, DDPM trainer, and Local SDXL LoRA Trainer use real adapters and never fall back to simulated training.

Existing program folders can be connected from Settings → Tool folders. ADAM stores only the path and scans for likely entry points; it does not copy or modify the external project. Folder assignments can also be pasted into chat:

DDPM Trainer: D:\AI\DDPM
Flow Matching Trainer: D:\AI\FlowMatchImageGenerator

On a new computer, install requirements.txt in your chosen Python environment before running Launch ADAM.bat. The launcher checks desktop dependencies and does not install packages automatically or depend on the developer's personal trainer folders. Install each optional trainer's dependencies according to that tool's setup instructions before using its ADAM workflow.

Remote access is disabled by default. Devices with an access token can browse datasets, edit captions/review marks and submit work. Only enable it for trusted devices. The desktop Allow remote job controls and approval changes setting also permits remote confirmation, stopping and retrying jobs. A remote browser can enable training auto-approval only after that desktop permission is granted; it can always turn auto-approval off. Saved token changes and disabled access take effect for new requests without restarting the server.

Use private Tailscale access for connections beyond a trusted local network; the built-in HTTP listener does not provide transport encryption by itself. Phone URLs and QR codes contain the access token and should be treated as credentials. Remote commands require JSON, have bounded request sizes and connection counts, and reject cross-site browser submissions. These controls do not sandbox installed Python plugins or connected trainers: install only code you trust.

Detection does not automatically authorize training. A real training adapter remains gated until its dataset, model name, run settings, and output location are explicit.

Training agents

ADAM's training lifecycle is divided into four explainable responsibilities:

• EVE reviews dataset membership and leaves uncertain images for the user.
• ORION reviews planned epochs, batch size, resolution, image exposures, and estimated optimizer steps. He can require approval but never silently changes the requested settings. In the Model Creation Assistant, ORION: apply a starting recipe fills a conservative, editable draft from the image count and selected resolution before a plan is built.
• ATLAS watches active training for non-finite loss, sustained critical GPU temperature, critically low disk space, stalls, and large runtime overruns. Critical conditions pause the trainer process tree so the user can inspect it.
• NOVA examines available post-training previews and samples for unreadable files and exact-looking duplicate collapse. Her report explicitly separates technical sample health from subjective or subject-quality review.

ORION, ATLAS, and NOVA reports are stored with each durable job record and are shown in Current Plan, Active Job, and Jobs / History respectively. ATLAS's default thresholds can be overridden in config/settings.json with the atlas_* settings defined in adam/config.py.

Every new job passes through the shared preflight and ORION review before its queue state is chosen. Desktop plans, Remote prompts, and Remote training forms use the same review. Remote training auto-approval still applies to ordinary plans, but an ORION warning leaves the job awaiting explicit approval. Reviewing a plan does not change the requested training settings.

Real image collection

When a valid Dataset Collector folder is connected, the dataset_collector registry entry uses ADAM's real visible-browser adapter. After plan approval it:

• opens Bing Images in a normal visible Chrome window;
• waits when consent/CAPTCHA/human-verification text is detected;
• resumes automatically after the user resolves the page;
• downloads valid images at least 256×256;
• removes exact duplicate downloads;
• writes a matching .txt caption beside every image; and
• records URLs, captions, sources, and dimensions in metadata.csv.

No CAPTCHA or website restriction is bypassed. Closing Chrome or stopping the job ends collection safely. A new timestamped dataset folder is used rather than overwriting an existing collection.

ADAM keeps an incomplete DDPM request in conversation memory. A follow-up such as dataset folder Mario, model name Mario V2, epoch count 100, output D:\Runs fills the pending fields and validates named datasets against the connected collector. It will not start if the dataset cannot be found.

Showcase videos

The Showcase Video workspace creates a finished MP4 directly from completed DDPM and Flow Matching models. Select and reorder the models, choose 12–24 images per model, a 3-, 4-, or 5-second image duration, shared steps and aspect ratio, provider-compatible samplers, seed, and 720p or 1080p output. ADAM runs the image batches sequentially and then renders a request-list interface that tracks the active model, image number, trainer, steps, sampler, and aspect ratio. LoRA models are intentionally excluded from this streamlined workflow.

When Ollama is reachable, messages that are not workflow commands receive a conversational answer. In Chat Mode, attach an image with the + button and a vision-capable Ollama model can describe it, suggest a caption, or answer questions about visible details. Images stay on the local Ollama connection.

In Trainer Mode, the planning model can propose a registered ADAM action when the request is not recognized by the built-in planner. ADAM validates the proposed tool and every setting against its registry, and confirmation gates still apply. This option can be disabled in Settings → Safety & Notifications.

Web search in Chat Mode

Chat Mode can give local Ollama current web context without an API key. Enable it in Settings → Planning model, then ask naturally, for example:

Search the web for Dandy's World character ideas.
What are the latest Ollama release notes?
Look up a reference for a cyberpunk city character.

ADAM sends only that search query to Bing's public results feed, reads the result titles and snippets, and passes up to five titles, snippets, and links to Ollama. It does not open the result pages, download anything, or let web content run tools. Results are untrusted reference material, so ADAM is instructed to cite the links and flag uncertainty. Disable the setting to keep Chat Mode fully local.

When you explicitly ask ADAM to read, open, or research result links, it can read up to three public HTML/text pages and give Ollama short extracts. For example: Search the web for Undertale character ideas and read the most relevant links. Direct links can be read with Read https://example.com/ and summarize it. Private/local addresses, non-web protocols, oversized pages, downloads, and more than three pages are blocked. This control can be disabled in Settings.

Planning runs away from the interface thread, and conversational Ollama output is streamed into the chat. ADAM validates training commands against a strict schema and each registered trainer's declared capabilities before offering a job.

In Settings → Planning model, choose an automatic, short, balanced, or detailed response style. Automatic uses a smaller response for simple questions and makes more room for image reviews, explanations, and planning. Maximum response length remains a hard limit for response time and GPU memory; the default is 1,024 tokens.

ADAM stores friendly dataset/model names, paths, trainer types, epochs, and resume checkpoints in data/assets.json. Requests such as:

From the Mario dataset, train it on a DDPM for 300 epochs.
With the Mario dataset, train it on a LoRA for 100 epochs.
Continue the Mario model from the DDPM for 50 epochs.

are resolved to real paths before approval. Continuation is offered only when a compatible checkpoint exists. New DDPM runs retain the latest resume checkpoint.

Run

python main.py

On Windows, you can also double-click Launch ADAM.bat.

The app requires Python 3.10+ and PySide6. Optional integrations use psutil for system information and pynvml for NVIDIA GPU information.

python -m pip install -r requirements.txt

Try:

• Click Create a model… in Trainer Mode for the guided Model Creation Assistant.
• Adam, train a LoRA of Hatsune Miku
• Adam, collect a dataset of liminal spaces
• Adam, generate previews
• Adam, check GPU status
• From the Mario dataset, train it on a DDPM for 300 epochs
• With the Mario dataset, train it on a LoRA for 100 epochs

Training and large collection plans are never started until you approve the plan. All actions are recorded in logs/adam.log, while project artifacts live under data/projects/.

The Model Creation Assistant can start from a built-in Character LoRA, Style LoRA, DDPM, Flow Matching, or experimental PixelRow preset. It can create a dataset or select a registered one, recommends starting values, and saves personal presets. The result still goes through ADAM's normal validated planner and approval gate. Use + Add model to build a multi-model training batch. Each wide model tab keeps its own dataset, trainer, name, and settings; the minus button removes an unwanted model, and tabs can be dragged to change the run order. ADAM validates all models, presents one combined approval plan, and runs them sequentially so only one training workflow uses the GPU at a time. A failed step stops the batch before a later model starts. Before approval, ADAM adds checks for connected tools, dataset contents, the LoRA base model, and output-drive free space. Completed dataset and training jobs also include a suggested next step.

Model Batch Builder

Use Create model batch… to paste one requested subject per line. ADAM turns the list into editable model tabs, removes duplicate names, and lets the current trainer recipe be applied to any multi-selection of models. The batch is saved as a draft so it can be closed and resumed later.

For a review-first workflow, choose Collect missing datasets first. This queues only sequential dataset collection and leaves training in the saved draft. After collection, reopen the draft, use Find collected datasets, and review each dataset in Training Studio. Exclude rejected moves rejected images out of the training folder into a recoverable quarantine, and Restore excluded reverses it. Keep all images marks the whole selected dataset as accepted in one action, after which individual bad images can still be rejected. Training remains locked until each model is explicitly marked as reviewed and ready. If every linked dataset is acceptable as-is, Approve all datasets marks the entire batch ready after one confirmation; it does not inspect individual images or apply pending rejection decisions.

Completed Flow Matching models can be selected in Fine-tune. ADAM uses the saved Flow model folder as the continuation source, locks the continuation to the model's original resolution, and writes the fine-tuned result to a new output folder. This continues the saved weights while starting a fresh optimizer and learning-rate schedule; it does not overwrite the original model.

PixelRow

PixelRow is ADAM's experimental top-to-bottom image architecture. It trains on ordinary image folders and predicts one complete quantized RGB row from all previous rows, without a diffusion noise schedule. Start with 64×64 images for the first experiment; 128×128 is available but trains more slowly.

PixelRow generation uses one step per image row. The Generations page labels these as Rows and offers creativity, top-color-choice, and row-frame settings. Enabling Save row-build frames writes a PNG sequence beneath the generation folder, making the construction process ready for a video or visual comparison. Seeds reproduce both the finished image and its intermediate rows.

Wan Video LoRA

Open Video LoRA in the sidebar to use the connected LoRAVideoTrainer from inside ADAM. This workspace is separate from the image-model creation assistant and image Generations page. It targets Wan 2.1 T2V 1.3B only.

Connect Settings → Tool folders → Wan Video LoRA Trainer to your existing LoRAVideoTrainer folder. An existing external_loravideotrainer connection is recognized automatically. ADAM runs its .venv/Scripts/python.exe and installed Musubi Tuner; use that project's setup instructions for its CUDA dependencies and base weights. ADAM does not install or replace the trainer environment.

1. In Dataset, choose a folder of short video clips with matching .txt captions, import clips, or use Split long video. Splitting creates a new folder of evenly spaced 49-frame clips at 12 FPS, preserving the source. Select clips for looping preview and caption editing. Captions save on selection/tab changes; include the exact trigger word from Training. Characters & recognition maintains a local character library with one or more reference images per character. It samples several frames from each clip and uses local DINOv2 visual similarity to suggest zero or multiple characters. Review the suggestions and uncheck false matches before applying trigger words to captions; existing action descriptions are preserved. Recognition suggestions are not applied automatically, and similarity scores are only a review aid. Character references and the library are stored under data/video_characters/. To draft action captions, select one or more clips and choose AI draft captions. ADAM samples six ordered frames per clip and asks the configured Ollama model to describe visible actions and changes without guessing who is present, in English. It retries once if the model returns CJK text. Review and edit each draft as soon as it finishes while the next selected clip is being processed. ADAM trims notes, alternate summaries, and repeated commentary to one short caption sentence. Check the captions to keep, then save; ADAM adds the active training trigger automatically. Failed clips remain unchanged, and unchecked drafts are not written.
2. In Training, enter a unique run name and review epochs, trigger, frame buckets, training resolution, rank/alpha, learning rate and memory swapping. Review full training pipeline creates a job awaiting approval in Jobs / History. After approval it validates clips, caches video latents, caches captions, then trains. Failures stop subsequent stages.
3. In Generate, choose a compatible checkpoint and set prompt, strength, landscape/portrait format, seconds, FPS, steps, seed and block swapping. ADAM converts duration to Wan's 4N+1 frame count and displays the actual duration. Start with Fast preview preset before trying longer clips.
4. Videos / takes lists new MP4s with prompt/seed/settings and existing samples from the connected trainer. Double-click to play a video.

Training outputs default to data/video_models/<run name>/, including an isolated cache, dataset configuration, logs and model metadata. Existing output folders cannot be overwritten. Continue weights loads a Wan adapter into a new run with a fresh optimizer and schedule; its rank and alpha come from the checkpoint. It does not restore a full interrupted optimizer state. Cancellation keeps previously written checkpoints, but does not force a new checkpoint.

Generations are stored in data/video_generations/, with an MP4 and generation.json recording the actual seed, model, prompt, settings and output dimensions. Existing Wan checkpoints in LoRAVideoTrainer's output/ are indexed separately from SDXL. The first visit imports compatible local trainer settings; subsequent changes are saved in ADAM's own configuration. The original trainer's storyboard editor remains available through that application.

All work uses ADAM's shared job queue, logs and pause/cancel controls. Training keeps ORION review and ATLAS supervision, with video-specific workload notes. NOVA requests video samples instead of applying image-preview quality checks. Chat requests mentioning Wan or video LoRA direct you to the dedicated workspace.

Training Studio

The Training Studio turns completed work into a reviewable experiment loop:

• Datasets provides an image gallery, keep/reject decisions, caption editing, exact duplicate detection, and visually similar duplicate candidates.
• Experiments compares job settings and outcomes, opens outputs, marks a preferred model, and converts successful settings into reusable recipes.
• Checkpoint Lab browses model checkpoints and output images, records consistent prompt/seed evaluations, and sends preview requests through the normal approval-aware planner.
• Recipes preserves training starting points and can import or export portable JSON recipe files.

EVE AI Dataset Review

In Training Studio → Datasets, EVE AI Review… performs a local reference- guided visual review. Add one or more good reference images and optional bad references, then choose Keep and Reject confidence thresholds. EVE uses a small DINOv2 vision model to divide the selected dataset into Keep, Reject, and Uncertain galleries with confidence scores. The model is downloaded once on first use and subsequent analysis stays local.

Nothing is applied automatically. Inspect both sides, double-click images for a full view, and move selected results between the three groups before choosing Apply EVE review. EVE's decisions remain ordinary Training Studio review marks: they can be manually changed, and rejected files are not moved until Exclude rejected is selected. The latest proposal is also saved under data/eve_reviews/ for auditing. Use Select all in current group (or Ctrl/Shift selection) to move many images at once; EVE transfers only the chosen thumbnails so manual sorting stays responsive on large datasets.

Training panels show elapsed time, a progress-based ETA, recent logs, and a loss sparkline when the connected trainer reports loss. Preflight summaries include clearly labelled workload, duration, VRAM, and disk estimates. These estimates are planning hints rather than hardware guarantees.

Create a Model also supports live training previews with a configurable epoch interval, prompt, and reproducible seed for each model tab. While a training job is active, its newest 256×256 preview appears in the right sidebar with the source epoch and next scheduled preview. The full-size trainer output can be opened from the card. Built-in adapters may publish previews directly; registered DDPM, Flow, LoRA, APVD, MaskGit, and other trainers can also participate by writing conventionally named preview, sample, or epoch images beneath their declared output folder.

INRFlow

ADAM includes an experimental, lightweight INRFlow trainer and generator as a separate built-in model architecture. It follows the paper's ambient-space design: an image is represented as coordinate-to-RGB pairs, spatial context latents summarize the current noisy field, and a point decoder predicts the flow velocity for independently sampled pixel queries. Training therefore uses continuous flow matching directly on RGB values without a VAE or another pretrained image compressor.

The implementation is intentionally scaled for local experiments rather than the much larger published configurations. The 64px default is the recommended starting point on an 8–12 GB GPU. Pixel-query subsampling lowers training memory; batch size, query count, width, and resolution can be reduced further. Models save ordinary checkpoints, EMA weights, resumable optimizer state, metadata, and optional training previews beneath data/model_plugin_outputs/inrflow/.

Completed INRFlow models appear in Generations next to regular Flow Matching, with reproducible seeds, Euler or Heun integration, live ODE previews, Smart Generation, and square resolution-flexible queries. A different output resolution is coordinate-field extrapolation, so native resolution is the fair default for model comparisons. Creative notes are metadata because the current backend is unconditional.

This is an independent ADAM-sized implementation informed by the INRFlow paper and Apple's reference repository, not a copy of the published training setup or a claim of reproducing its reported model scale.

Generations

The Generations workspace runs compatible registered image generators without opening their separate desktop interfaces. DDPM, regular Flow Matching, INRFlow, and PixelRow can generate from completed models with reproducible settings; PixelRow uses rows, while both flow backends use ODE sampling steps. Generation work uses the normal ADAM job queue, progress reporting, cancellation, and logging.

Every completed batch is stored under data/generations/ with its images and a generation.json sidecar. The history gallery can open an image or batch folder and restore the exact settings for another run. DDPM creative notes are stored with a batch for organization; they are not presented as text conditioning for an unconditional DDPM model.

The workspace groups controls into Model & Prompt, Image Settings, and Advanced Settings. Dimensions, presets, image count, and seed are available in Image Settings; sampling controls are expanded by default. Collapsing Advanced Settings preserves its values. Custom LoRA dimensions and reference images are remembered when reopening the page.

Generation history opens with image cards for each generator and a preview of the latest batch. Click a generator, then a model, to browse its images and select that model for generation. Recent Output, All Generations, and Favorites provide alternate history views. The thumbnail strip selects the image shown alongside its metadata and reuse/save actions. In Compare, pin one image as a reference and select another thumbnail to view them together. Long metadata values are available in tooltips. These views do not move or rewrite older generation files.

Generation Cycle… selects multiple compatible completed models and queues one generation step per model. Choose images per model, a shared prompt or creative note, starting seed, slideshow duration, looping, fullscreen playback, and an optional model/trainer label. When the cycle finishes, ADAM opens the results as a local slideshow while preserving every ordinary generation record in history.

If ADAM discovers a job interrupted by an unexpected shutdown, it offers to open Jobs & History. The previous record remains intact and can be retried as a new approval-gated job. Job logs can also be exported for troubleshooting.

Connect an existing tool

ADAM supports importable Python functions and command-line Python scripts. For a no-code setup, open Settings → External Tools → Add external tool. Choose the program folder, select its training entry script and important configuration files, then review ADAM's static compatibility and safety report. The report covers:

• detected command-line options and required inputs;
• likely dataset formats;
• output and checkpoint behavior;
• progress reporting;
• resume-training support; and
• potentially risky operations visible in the selected entry script.

The 1–10 rating measures how clearly the script fits ADAM's safe command-line contract. It is not a guarantee that third-party code is harmless. ADAM does not execute a script while scanning it, external tools cannot replace built-in registry entries, and every external-tool run requires explicit approval.

After registration, a tool can be planned with a request such as:

Run APVD Model Trainer with dataset=D:\DreamData, epochs=20, output=D:\APVD\output

ADAM will ask for any required inputs that were omitted before it offers the approval plan.

For manual registry configuration, edit the relevant item in config/tools.json:

{
  "backend": {
    "type": "python",
    "module": "my_tools.lora",
    "function": "train"
  },
  "demo": false
}

The function receives a ToolContext as its first argument and keyword arguments from the approved plan. This keeps training code in one place: your existing GUI and ADAM can both call the same backend.

For scripts:

{
  "backend": {
    "type": "script",
    "path": "D:/AI/LoRATrainer/train.py"
  },
  "demo": false
}

ADAM invokes scripts directly with the current Python interpreter, captures stdout/stderr, and never drives another GUI with mouse clicks.

Safety model

• Plans are shown before execution.
• Long, destructive, or high-volume work requires confirmation.
• Unregistered tools cannot be invoked.
• External paths and arguments are validated before execution.
• The LLM may propose a plan, but only registered tools can execute it.
• Pause, resume, and cancel controls are available for active jobs.
• Every tool action and state transition is logged.

Tests

python scripts/run_tests.py
`

The runner executes every test module in its own process, keeping Qt application
lifetimes isolated. A single module can also be run with
python -m pytest tests/test_agents.py -q.``