Dispatching work

The whole job of o8 is to turn a described outcome into a reviewed, merged change — without you babysitting each step. Here's the loop.

From task to merge

1. Create — the orchestrator reads the task (say, a set of GitHub issues) and opens a mission.
2. Plan into a graph — it breaks the work into packets and orders them as a dependency graph, so independent packets can run at once.
3. Dispatch — the scheduler launches the first wave: every packet with no unmet dependencies, in parallel.
4. Isolate — each agent gets its own git worktree. Main is never touched.
5. Supervise — o8 watches each agent's progress without spending a model call on it: detecting when one is stuck, retrying, tracking completion.
6. Relay context — when an agent finishes, its summary and changed files are captured and injected into the prompts of the packets that depend on it. The next wave starts already knowing what the last one did.
7. Review — the finished diff gets a verdict (see Review & approval).
8. Next waves — dependent packets start as their prerequisites clear, wave after wave, until the mission is done.
9. Merge — the merge runs through the policy engine, not as a raw git merge. Nothing lands that the gate didn't clear.

The short version: create → plan → dispatch → review → approve. Every feature in o8 serves that loop.

One agent, one worktree

The isolation is literal: o8 runs git worktree add onto a fresh branch and the agent works in its own directory. That buys four things:

• No conflicts — agents on different issues never step on each other, and main is never touched.
• Real parallelism — a whole wave runs at once.
• Damage containment — if an agent goes off the rails, the worktree is removed and it's gone.
• GitHub as source of truth — branches, PRs, and status are native, not a side database.

When the work is good, the branch is pushed, a PR opens from it, and the worktree is cleaned up after the merge.

The runtimes

o8 doesn't talk to any one coding agent directly. It talks to a single contract — AgentRuntime — and every coding tool is an adapter behind it. Four ship today:

• Claude Code
• Codex
• Gemini
• opencode

Because the control plane only ever speaks the contract, adding another is a small, well-shaped change — any agent that runs in a terminal can be plugged in. The contract normalizes the things that matter: spawn, attach, steer, stop, telemetry, approvals, artifacts. Capabilities are explicit, so the interface only ever shows controls a given runtime actually supports.

Where you sit

The orchestrator plans, dispatches, supervises, and audits — but the merge runs through the gate, and you approve what matters. Plans are reviewed before they execute. You can run the room from the desktop app, from mobile, from any agent that speaks MCP, or headless via the CLI — the same governed loop underneath all four.