Node 22 · macOS, Linux, Windows · subscription auth only

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.

Read the README
AI Maestro

bookmark-folders

bookmark-folders-mk7f2abase main8 nodes · 4 waves
running 0m 00s Live Pause Stop Replay Analytics Coordinator
−+

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.

    NodeWaveHarnessLaneStatus

    Integration worktree

    Every merge, wave suite and conflict fix runs here, one at a time.

    Idle.
    3harness adapters: claude-code, codex, opencode
    0API keys handled. It drives CLIs you are already logged into.
    1JSON file is the executable artifact, schema-validated
    ∞crash-safe: the journal rebuilds state on every boot

    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-loop once gates are green.
    • Editable in the browser with the same state-machine editor used across Vinta's tools.
    pipelines.standard-phase
    implement→ gate→ review→ polish→ verify→ integrate→ done
    exit ≠ 0 ⟲fix round 1 / 2 · same implementer, same session
    guard: gate.exit_code == 0 && review.verdict == "pass" · effects: spawn_agent run_gate run_chore git_merge open_pr await_human

    What 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.

    node contextnode redirectnode interruptnode reassign --crewnode retrynode freshnode answernode stepswitch-harnessfixer reassignamendpausestop
    steering a live run

    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 ui

    Serves 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 · stop

    What 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 --lanes

    Deletes run state, lane worktrees, their databases and compose stacks. Resumable runs are kept unless named.

    architecture
    Browserlocalhost or port-forward
    Run graphlive DAG
    Node detailtranscript, steer
    xtermPTY takeover
    Editorworkflow + pipeline
    vinta-ai-maestro uistatic app · journal reads
    Forwardsa live run's API and socket to its job, swapping tokens
    One run's jobrun --foreground, detached
    Schedulercontinuous DAG
    Resource poolscapacities
    Gate runnercached by tree
    Pipeline interpreterstate machine per node
    Harness adaptersclaude-code · codex · opencode
    Lane managerworktrees + db forks
    JournalSQLite events + transcripts

    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.

    Read the spec Start with AI Workflows