Orchestrating Coding Agents
Boards like Vibe Kanban made it easy to run several coding agents in parallel — assign cards, watch them work in isolated worktrees. But orchestration routes the work; it doesn't make the agents agree. Here's the layer that does.
AI agent orchestration — running several coding agents in parallel and routing work between them — is the hottest pattern in agentic development right now. The leverage is obvious: split a project into cards, hand each to an agent, review what comes back. But teams that scale it hit the same wall: the agents don't share what they know, and "parallel" turns into "three different answers to reconcile." This page is about orchestrating agents that actually converge.
The three pieces of orchestration
- Routing — deciding which agent takes which task. A board like Vibe Kanban does this with kanban cards; some teams use a controller agent that dispatches sub-agents.
- Isolation — keeping agents from colliding. The standard answer is a git worktree per task: each agent gets its own branch, terminal, and dev server.
- Shared context — making every agent work from the same team decisions. This is the piece most setups skip, and it's where output quality is won or lost.
Routing and isolation are largely solved. Tools like Vibe Kanban handle both cleanly — plan on a board, and each card runs in its own worktree. The gap is the third piece.
Why parallel agents diverge
Picture three cards in flight: one agent refactoring auth, one adding a feature, one fixing a bug. Each sits in its own isolated worktree, and each starts from zero on your team's conventions — the patterns you standardized on, what you've tried and rejected, who owns what. So the refactor uses one error-handling style, the feature uses another, and the bugfix reintroduces an approach you abandoned months ago. The orchestration worked perfectly; the output is incoherent, and you spend the time you saved reconciling it in review.
This isn't a flaw in the board. Routing and context are simply different layers — and the more agents you orchestrate, the more the missing context layer hurts.
The fix: orchestrate on shared context
Give every orchestrated agent one source of truth to read before it works. When the auth refactor, the feature, and the bugfix all start from the same context — your conventions, your decisions, your ownership map — they converge on consistent output instead of diverging. The board still routes; the context layer makes the routed work coherent.
First-Tree is the shared-context layer for orchestration.
It's an owned, versioned context tree of your team's decisions that every agent reads on every task — in every worktree, on every card — loaded via a SessionStart hook. Pair it with whatever orchestrator you use (Vibe Kanban, a controller loop, your own board) and your parallel agents stop guessing your conventions independently. Routing × isolation × shared context is what makes multi-agent orchestration actually reliable. Open source and free.
Putting it together
- Route with a board — see First-Tree vs Vibe Kanban for where the board ends and context begins.
- Isolate with git worktrees, one branch per agent.
- Share context with First-Tree so every agent's loop runs from your team's decisions.
- Standardize the per-agent setup with a tight CLAUDE.md and reusable commands.
That's the full picture of agentic coding at team scale — and the foundation of running real AI agent teams where orchestrated agents act like they share a brain.