How the work gets split and coordinated.
Coordination is the hard part. A planning agent turns your spec into a task graph, assigns specialists, and manages the handoffs between them so the pieces fit.
The planner decomposes the spec
A planning pass reads the full spec and produces a task graph - discrete units of work, each tagged with the agent that owns it and the outputs it must produce.
Dependencies decide the order
Tasks that depend on the schema wait for it. Independent work runs in parallel - the frontend can scaffold its shell while the backend wires up endpoints.
Handoffs are explicit
When an agent finishes, its output becomes an input for the next. The backend reads the exact schema the schema agent committed - nothing is re-guessed.
Watch a handoff happen.
The schema completes, which unblocks the backend. Two agents run at once where the plan allows it.
"teams, roles, tasks"
Schema Agent
queued
Backend Agent
queued
Frontend Agent
queued
Infra Agent
queued
Where a human still steps in
Orchestration is not fully hands-off yet, and we would rather say so plainly. At a few points - confirming inferred data relationships, approving destructive changes, and signing off on deployment configuration - the build pauses for a review step. Those checkpoints are marked in the build view as needs-review, and the pipeline waits for your go-ahead before continuing.
One model guessing, versus specialists agreeing.
- Holds the whole system in one context and loses detail
- Backend and frontend drift out of sync
- You find the gaps after everything is generated
- A change means regenerating large chunks at once
- Each agent focuses on one layer and does it well
- Handoffs keep every layer consistent with the schema
- Problems surface live, where you can redirect them
- A change replans only the tasks it actually touches
Coordination you can actually watch.
Start a build and follow the task graph as agents pick up work and hand it off.