You can change settings over and over and still have no idea which one helped. I wanted o8 to test its setup against the workload and adjust from there.
o8 is open source today. MIT.
Agents do the work. You run the room.
One orchestrator scopes what you asked for and dispatches a fleet across 13 agent runtimes. Every worker stays isolated in its own git worktree. Nothing merges until you approve it.
• Approve what ships — every diff reviewed, high-risk work escalated, your sign-off on the merge
• Use the agents you already pay for — Claude Code, Codex, Gemini, opencode, one adapter contract
• Canvas — turn the IDE into a work surface and work with the thing itself
• Speak to the whole system — Symon dispatches by voice through the same gate
• Run the room from your pocket — approve or reject from your phone
• The fleet remembers the work — repeated fixes come back as rules you accept or reject
Fork every line. Change the interface, add a runtime, replace a workflow, or ship your own build.
Free, macOS, runs on the subscriptions you already have. 30 releases in the last 14 days. I built it with itself.
Repo in the first reply.
0.1.584.
huddle plans reach fleet. the mic opens as audio ducks.
files open and save anywhere. finder stays on your surface.
declined reviews say why and pulse orange. request changes goes to orchestrator. discard stays recoverable.
relaunch o8 and it's yours.
0.1.585.
Every agent state lives on one canvas now — the motion is the state, the color is the severity.
Reviews say why they were declined. Files open on any path. Idle CPU is down, cold launch is traced.
Relaunch o8 and it's yours.
Interface craft: We reorder worktree rows with FLIP, so the table keeps identity while priority changes. It fits review queues where sorting should feel traceable.
const first = https://t.co/ZidZmv86V1(r => r.getBoundingClientRect());
sortByRisk();
rows.forEach((row,i) => {
const last = row.getBoundingClientRect(), dy = first[i].top - https://t.co/nGqdeugvK4;
row.animate([{transform:`translateY(${dy}px)`},{transform:'none'}], {duration:420,easing:'cubic-bezier(.2,.8,.2,1)'});
});
Hand the snippet to your coding agent — or just point it at this post — and it'll build it for you.
o8.
a fleet of agents does the work.
you keep control.
review every diff. approve what ships.
nothing merges without you.
free beta → https://t.co/C6zedyM5MM
Last night we ran Fable 5 in o8.
We were able to maximize token reduction by 26 times.
Ran a few experiments handicapping Fable to a small window to look through and filling that window with the perfect information for the task.
One raw (tool access) call sends 9 times MORE context than using o8’s Fable 5 through the API, these savings will transition directly to Claude subscription usage when Anthropic brings it back - sometime after the 7th.
Since Codex (or any model you want) is the worker the output is minimized as well, reduced to a dispatch. Where Fable is needed it is deployed as seen in the experiment, the workers issues were diagnosed and the fix approved by the user.
Notes on one of those experiments below, one of many I ran Live last night on stream.
Big caveman version:
Fable = huge brain, expensive to feed.
Old way: give Fable whole mountain of rocks every time. Fable read files, logs, tools, transcripts, everything. Big smart, but eats tokens like fire eats wood.
New o8 way: cheap helpers carry rocks. Fable only sees small carved stone that says: “what happened, what matters, what decision needed.” Then Fable says **approve / reject / hold / ask human**.
What yesterday’s commits did:
- Added Fable as a metered orchestrator.
- Locked Fable away from raw tools: no file reads, no shell, no web, no raw transcript dumping.
- Let fixed-cost lanes do the heavy reading: Brain, Codex digest, compact summaries.
- Added `digest()` for big messy stuff.
- Added `fetch_raw` only as a small emergency hole, rate-limited and capped.
- Dropped metered compaction threshold from normal huge-window behavior to around 15K tokens, so expensive context doesn’t bloat.
- Added benchmark receipts to the o8 benchmark page.
Numbers in caveman:
- Normal tool-loaded decision: about 9,700 input tokens.
- o8 Fable window decision: 374 input + 183 output = ~550 total.
- That is 26× less input per decision.
- Hard review: raw was 32,720 tokens, window was 3,544.
- That is 9.2× less context, with no measured quality loss.
- Cached doctrine made the standing rules about 76% cheaper on input.
- Fable matched the human operator 80%. Opus successor matched 68%.
So the real thing is:
o8 made Fable stop being worker. Fable became judge.
Worker reads cave.
Brain summarizes cave.
Fable sees small stone.
Fable makes decision.
Human still owns final gate.
That’s the product story. Not “we used a better model.” It’s “we built a machine that makes the expensive model only spend tokens where judgment matters.”