---
title: "Dispatching work"
description: "How a task becomes a merged change — missions, isolated worktrees, the runtimes, and where you sign off."
canonical_url: https://o8.run/docs/dispatching-work
md_url: https://o8.run/docs/dispatching-work.md
last_updated: 2026-06-25
version: "0.1.431"
stability: stable
---

# Dispatching work

> How a task becomes a merged change — missions, isolated worktrees, the runtimes, and where you sign off.

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](/docs/review-and-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.