Solo agents run out of room.
Plan, execute, review, and ship in one voice eats the context window before anything lands. More compute doesn't fix what's structural.
00 — o8
An orchestrator that delegates, reviews, and ships.
One primary orchestrator routes scoped work to specialized sub-agents. A governance layer reviews every output before it touches your main branch. Local-first. Any model.
Download for macOS ›v0.1.7alpha · macOS (Apple Silicon + Intel) · free during alpha · bring your own keys
00.1 — Commitments(TRUST)WHAT o8 WON’T DO
(LOCAL-FIRST)
Your code never touches our servers. Everything runs on your machine.
(YOUR KEYS)
Your API keys. Your quota. Your rates. o8 doesn't mediate or meter.
(NO ACCOUNT)
No signup. No telemetry. Download the binary and run it.
(SOURCE PRIVATE)
This repo is the changelog. The engineering source stays private.
00.2 — For whom(AUDIENCE)SELF-SELECT
(SOLO BUILDERS)
Stretch a paid plan across plan, build, and ship without running dry.
(AGENT FLEETS)
Watch parallel sub-agents work. Steer mid-flight. Approve what merges.
(NIGHT SHIPPERS)
No session reset. Pick up tomorrow where today's dispatch left off.
(SMALL TEAMS)
Shared governance and memory. Separate accounts for each operator.
01 — Problem(CONTEXT)
Context windows balloon when one agent does everything.
A single agent stretched across plan, execute, review, and ship runs out of room before it ships anything. The usual workaround is more compute. The actual fix is more structure — delegating scoped work to sub-agents so the orchestrator stays lean enough to reason.
01.1 — Failure modes(SOLO AGENTS)01 / 05 — swipe or drag
The reviewer is the author.
A single agent marking its own work has no second opinion. It approves what it wrote and moves on.
Claimed work that never happened.
Agents narrate dispatches they never fire. The operator reads the text, believes it, walks away.
Code lands without a second look.
Without a gate, the first thing to pass the model's self-check hits main. Regressions ride along.
A solo agent burns a monthly plan in days.
Holding full context in every turn chews through paid-plan quota faster than it ships. Delegation keeps the orchestrator turn lean; sub-agents run on their own quotas.
02 — System(ARCHITECTURE)
A pipeline, not a prompt.
The orchestrator decides what needs to happen. Sub-agents execute in isolation with only the context their task requires. Governance sits between the sub-agent output and the base branch.
02.1 — Layers(EACH LAYER)01 / 06 — swipe or drag
Routes, reviews, signs off.
The top layer decides what needs to happen and who does it. It reads diffs. It never writes production code itself.
Isolated worktree, scoped context.
Each sub-agent runs on its own branch with only the files and prompt its task requires. No shared state during execution.
The gate before main.
Every sub-agent output passes through typecheck, static checks, and orchestrator review before anything merges.
Lessons persist across sessions.
Review findings and dispatch patterns feed back into future prompts. The system gets harder to fool over time.
Every decision has a hash.
Approvals, reviews, and merges all land in a durable ledger. You can retrace any shipped change to the conversation that produced it.
Not a headless pipeline. A control surface.
Headless daemons route and gate. What's missing is a window for the operator to see what's happening, steer mid-flight, and approve what ships. o8 is that window.
03 — Position(COORDINATES)
Where o8 sits.
Not every orchestration tool makes the same tradeoffs. Here is how o8 lines up against the axes that actually matter.
03.1 — Each axis in depth(THE TRADEOFFS)01 / 05 — swipe or drag
No single agent holds the full task.
Work is split into packets small enough to finish cleanly in one turn. Context stays lean because nothing tries to hold everything.
Every merge goes through review.
The orchestrator reads the diff, runs the gates, and writes a verdict. Nothing ships without a signed record.
Drift gets caught, not accumulated.
Lane reconcile catches orphaned work. A supervisor watches for stuck sessions. Bash-merge paths and verb paths both reconcile back to clean state.
Any model, same floor.
The governance layer enforces quality mechanically. The model tier becomes a cost and speed knob, not a correctness knob.
One operator, many workers.
Parallel sub-agents work in isolation. The orchestrator stitches outputs together. A single human reads the summary, not the stream.
04 — Governance(REVIEW)01 / 06 — drag
Review before ship.
Every sub-agent output passes through a gate before merge. Typecheck, static checks, diff inspection, audit. The orchestrator signs off or returns it for a fix.
THE GATE
← drag to advance →
TypeScript passes, always.
No sub-agent output reaches main until tsc says yes. Type regressions are caught before the review turn even starts.
Banned patterns never ship.
Structural rules run on every diff. Violations fail the lane, block the merge, and return the turn to the sub-agent with a fix-it steer.
The orchestrator reads every change.
Not summaries. Not status signals. The full diff, file by file. Every verdict is grounded in the code, not the narration.
Signed trail of every merge.
Each merge carries a decision record: reviewer, timestamp, findings, and the commit range it covers. Nothing is implicit; nothing goes untraced.
Large files split automatically.
Oversized modules trigger follow-up work the moment a merge lands. Main stays clean as the system grows, without anyone having to ask.
05 — Building itself(PROOF)01 / 06 — drag
The loop sharpens itself.
o8 dispatches against o8. Every pass ships features, catches its own friction, files the bugs, and merges the fixes.
← drag to advance →
A full epic shipped end-to-end.
Ten scoped packets dispatched, reviewed, and merged in a single operator session. Plain-English dispatches, no tool IDs typed.
2026-04-16 SESSION
Friction self-filed during the run.
Every rough edge from the same session became an issue before it recurred. The loop generates its own regression backlog.
The bar lifts in one sitting.
Human-through-product dogfood score climbed fifteen points after the same session's hand-fixes landed. The loop sharpens itself on every pass.
The system dispatches against itself.
Bugs filed, packets written, sub-agents ship patches. The orchestrator reviews the fix the same way it reviewed the feature. Same pipeline, both directions.
Drift gets caught, not accumulated.
Stuck lanes recover. Orphaned worktrees get healed. Even the paths that bypass the primary handler land in a valid state by the next tick.