Baton - Agentic Orchestration Framework
The Secret Behind Fable 5 Ultracode and GPT 5.6 Sol Ultra and How Baton Takes It Further
Orchestration
Fable 5 offers six modes in its effort menu: low, medium, high, xhigh, max, and ultracode. You would assume ultracode simply makes the model think deeper. It doesn’t. Ultracode runs at xhigh, one level below max. Yet it costs the most and scores highest on benchmarks.
How can it perform better with a lower reasoning effort? The answer is orchestration.
How orchestration works
Ultracode quietly splits your goal into smaller tasks and delegates them concurrently to up to 16 sub-agents. Each sub-agent completes its task and reports back. The orchestrator reviews the results and either accepts or rejects them.
This keeps the orchestrator’s context window small. The main session holds only a high-level view of the project. Completed tasks, old file versions, failed attempts, and error logs never enter it. Each worker is isolated to a single task, so its context also stays small and focused.
The result is higher quality at lower token consumption. Which raises an obvious objection: ultracode costs significantly more. Anthropic and OpenAI charge a premium for orchestration, even though orchestration is fundamentally about reducing context, and therefore token usage.
It also raises a more interesting question: why does a larger context window increase token consumption while reducing quality?
Attention decay
The context window is everything sent to the model on every iteration, and you pay for all of it every time. A larger context means more input tokens. It also means worse performance, because the model’s attention is limited.
Many models accept context windows of up to one million tokens, but their attention is not evenly distributed across that window. The reason is training data. It consists overwhelmingly of short documents: articles, forum threads, code files, and chat logs. Even in datasets containing trillions of tokens, documents longer than 100,000 tokens are extremely rare.
Depending on the model, attention decay often begins somewhere around 100k tokens. Frontier models usually go well beyond that, but at the time of writing I have not seen one maintain strong performance past roughly 300k tokens. Read more about “Attention Decay”.
Past that threshold, the model starts missing facts it was explicitly given, violating constraints it previously acknowledged, and producing answers that feel like they came from a smaller, less capable model.
AI harnesses try to mitigate this by compressing the context, summarizing older information as the session grows. But summarization is lossy. It also cannot fully remove irrelevant information. Even in summarized form, completed tasks and error logs still occupy part of the model’s attention.
Orchestration avoids the problem entirely: most of that information never reaches the orchestrator in the first place.
Baton
By now you are probably wondering how to use orchestration without paying a premium. Ideally while reducing costs, since lowering token usage is one of orchestration’s main goals.
That is what Baton is for.
Baton is an open-source orchestration framework: a single-file Python CLI and standard library that turns the coding agent you already use into an orchestrator.
Every worker starts with a fresh context window and receives a concise capsule describing what to do, what counts as complete, what must not be changed, and how to verify the result. Non-overlapping tasks run in parallel. Before accepting any work, the orchestrator reviews both the worker’s report and the corresponding Git diff.
Baton also repeats important instructions at the beginning and the end of each prompt, where models retain information most reliably. This makes critical instructions less likely to be missed. Read more about “Lost in the Middle” effect.
Baton works with any harness, model provider, model, or reasoning effort, as either orchestrator or worker. It supports three worker tiers: hard, medium, and easy. Simple tasks, such as one-line fixes or straightforward refactors, do not require frontier-level reasoning and can be delegated to inexpensive models.
Requirements
Python 3.11+, Git, and macOS or Linux.
Install
Build from the prompt:
Give prompts/create-framework.md to a coding agent in the directory of your project. After it builds Baton, give prompts/improve-framework.md to a fresh agent in the same directory to test and repair it.
Or install the ready version:
git clone https://github.com/jpawchan/baton
cd baton
framework/baton init /path/to/projectHow to use
Tell the main coding agent to read .baton/orchestrator.md.
Describe your goal.
Setup examples
Strong setup:
Orchestrator: Fable 5, Max, Claude Code (stronger than ultracode)
Hard worker: GPT 5.6 Sol, Max, Hermes
Medium worker: GPT 5.6 Sol, Xhigh, Hermes or Kimi K3, Max, Hermes
Easy worker: Opus 4.8, Max, Claude Code or GPT 5.6 Luna, Max, Hermes
Good enough for most goals setup:
Orchestrator: Fable 5, Xhigh, Claude Code (same as ultracode)
Hard worker: GPT 5.6 Sol, Xhigh, Hermes
Medium worker: GPT 5.6 Sol, Medium, Hermes or Kimi K3, High, Hermes
Easy worker: GPT 5.6 Luna, Max, Hermes or Opus 4.8, High, Claude Code