Run a plan as a real, parallel, code-orchestrated run.
Maestro takes the workflow.json that plan-feature writes beside every plan and executes it: independent phases run at the same time in git worktree lanes, expensive gates queue behind capacity limits instead of stampeding, every event is journalled so a crash is a resume, and a browser UI shows the graph, the transcripts and the queue while it happens.
bookmark-folders
Click a node to see what it depends on and what waits for it; double-click to open it. Drag to pan, ⌘ or Ctrl + scroll to zoom.
Nodes
Status is the stream's where it has spoken, the snapshot's otherwise.
| Node | Wave | Harness | Lane | Status |
|---|
Integration worktree
Every merge, wave suite and conflict fix runs here, one at a time.
Same plan, two readings
An opt-in upgrade, not a replacement.
The zero-install path still works. implement-plan runs the same plan as a prompt with no daemon installed. Maestro is for projects that want a scheduler, a UI and a journal instead of a conductor prompt. Both read one description of the same semantics, so a plan written for one runs on the other.
implement-plan skill
- A prompt-shaped orchestrator shipped into the project as a skill.
- Runs inside your AI tool's session, lanes capped by the harness.
- Tracking written to markdown files on each phase branch.
- Zero install. The whole value of the skills path in a client repo.
AI Maestro daemon
- A continuous DAG scheduler: a phase starts the moment its dependencies are green and a lane frees up.
- Named resource pools with capacities, so the test suite and e2e queue instead of colliding.
- An event-sourced journal in SQLite. Pause, stop, resume, and survive a laptop going to sleep.
- A live graph, per-agent transcripts, PTY takeover, and steering of any phase mid-flight.
- Vendor capacity limits are backpressure, not failure: the node waits and resumes by itself.
The phase pipeline
Every phase is a state machine. Red gates loop back, green ones move on.
The plan graph says which phases exist and what each needs. The pipeline says what happens inside one: implement, run the gates, get reviewed one tier above the implementer, polish, verify, integrate. Transitions carry guards over a small documented context, evaluated by a hand-written evaluator that has no call syntax at all, so a plan edit can never become code execution.
- Gates are your commands.
pnpm typecheck,pnpm test,pnpm e2e, each with the pools it holds and a timeout. - A fix budget per phase. The scheduler owns the counter; the pipeline just reads it.
- The review is a chore that runs
thermo-nuclear-review-looponce gates are green. - Editable in the browser with the same state-machine editor used across Vinta's tools.
gate.exit_code == 0 && review.verdict == "pass" · effects: spawn_agent run_gate run_chore git_merge open_pr await_humanWhat you get
Built for runs that last hours and agents that write at once.
Worktree lanes
One lane per phase in flight, each a real git worktree with its own dependency copy, database fork and compose project. Sibling lane roots are denied at the OS level.
Resource pools
Declare test-suite: 1 and e2e: 1 and the daemon queues gates behind them. Gate results are cached by tree hash, so an unchanged lane never reruns a green suite.
Crash-safe resume
Every event lands in an SQLite journal inside the project. In-memory state is a projection, rebuilt on boot. Done phases stay done; everything else is attempted again.
Dependency-derived branches
A phase branches from exactly what it depends on. Chains become stacks; independent phases become short stacks reunited by wave merges, with a conflict fixer agent when they disagree.
Steer any phase mid-flight
Add context, redirect, interrupt without failing it, reassign to another crew member or harness at the same pipeline step, retry, or take the PTY over yourself.
No keys, ever
Harness adapters are process supervisors around claude, codex and opencode CLIs you already logged into. The daemon never prompts for, stores or forwards a credential.
Plan review in the browser
Before anything runs, read the graph, the plan, the gate matrix and the simulated schedule. Comment on a phase or a prompt, send to the agent that wrote the plan, watch it revise.
Questions answered in the UI
When an implementer stops with NEEDS_INPUT, the node parks, you get a notification, and the answer resumes the agent's own session with its context intact.
Backpressure, not failure
A vendor saying "not right now" is a wait, not a red phase. Harness fallbacks move a run to another account or CLI without pausing it.
Operator controls
Every button in the UI is also a command.
Steer from the browser or from a terminal on the same machine. Each verb is journalled with its reason, and the run prints what it did with it: sent, queued, held, delivered, or ignored.
Commands
Validate, simulate, run, land.
Every command runs against your project checkout. A run is a background job: close the terminal and it carries on.
$ vinta-ai-maestro validate <workflow.json>Checks the document, its graph and every plan anchor without running anything. plan-feature runs it on every workflow it writes.
$ vinta-ai-maestro review open <workflow.json>Serves the plan's review page: graph, plan, gates, schedule, and a chat with the authoring agent.
$ vinta-ai-maestro doctor <workflow.json>Preflights every check a run depends on: git, harness login, disk, databases, codegen determinism.
$ vinta-ai-maestro simulate <workflow.json>Projects the schedule without spawning an agent: wall clock, critical path, pool contention.
$ vinta-ai-maestro run <workflow.json>Starts the run as a background job and returns once it is under way. --resume picks a paused or failed one back up.
$ vinta-ai-maestro uiServes the browser UI for every run in the project and prints the URL. The URL carries the token; the host is loopback.
$ vinta-ai-maestro status · logs -f · pause · stopWhat every run is doing, its job log, a graceful pause with lanes intact, or a hard stop.
$ vinta-ai-maestro land <run-id>How a finished run lands: merge the plan PR with a merge commit, and close the review PRs whose work is already in.
$ vinta-ai-maestro purge --lanesDeletes run state, lane worktrees, their databases and compose stacks. Resumable runs are kept unless named.
Architecture
The daemon never edits code.
It spawns agents that do. Every write to the repository comes from an agent process inside a lane, or from a git operation the daemon runs that touches no file contents. Git is the durable record of work; SQLite is a cache of what the branches already prove.
- A browser UI, not a desktop app. The first time a run needs a bigger remote box, it is a port-forward, not a rewrite.
- Run state lives inside the project, gitignored, never in a global cache, with an explicit purge. Transcripts capture repository contents verbatim and are treated as data at rest.
- Every artifact path has one writer. Tracking is a directory, lane sandboxes deny sibling roots.
- The URL is the credential. Loopback binding behind a per-process token, and the browser never holds the job's.
Open the UI. Point it at a plan.
Node 22 or newer, git with worktree support, and a harness CLI you are already logged into. Docker Compose only if your workflow declares a compose-delivered database.