
One agent is the start: sub-agents and a dispatcher let many run at once.
A single agent is the starting point, not the limit. Inside one task, sub-agents do heavy reading in separate context windows and return summaries. Across a team, a dispatcher routes each request to an isolated runtime loaded with that person’s brain and credentials. Both trade more compute for cleaner context.
House martins fly out from one colony in every direction at once.
Tanush Jagdish · June 2026
Once an agent can finish real tasks, the next question is whether it can do more at once. It can, and one idea sits at the core of the method: spend more compute on a problem, but keep every context window clean. Rather than making one agent do everything in one crowded context, fan the work out to several agents, each with a fresh context, and bring the results back together. We call this multiplexing.
Published evidence supports the first half of that idea. In June 2025, Anthropic reported that in its analysis of the BrowseComp browsing benchmark, token usage alone explained 80 percent of the variance in performance, and that its multi-agent research system, a lead agent directing parallel sub-agents, outperformed a single-agent setup by 90.2 percent on an internal research evaluation. It also reported the price: such multi-agent systems used about 15 times the tokens of a chat interaction.
Multiplexing happens at two scales that are easy to confuse. Inside a single task, it takes the form of sub-agents. Across many people, it takes the form of a dispatcher that routes requests into isolated runtimes. Same instinct, different machinery.
#1Scale one: sub-agents inside a task
A sub-agent is one more tool. An agent already has tools such as reading a file, running code, and searching the web. Add one that starts a new model call with a fresh context window. That new agent can read an entire 50,000-word website on its own and hand back a 5,000-word summary, and only the summary enters the main agent’s context.
Holds the thread of what you want
- Read files
- Run code
- Search the web
- Start a sub-agent
Does the heavy reading elsewhere
Reads a 50,000-word website on its own, keeps what matters, and returns a 5,000-word summary. Its working notes are discarded.
Only the summary comes back, so the main agent’s context stays small and on task.
Keeping the main context clean is the point. Your main agent holds the thread of what you actually want, and every document it reads directly takes space in the one window that has to stay sharp. Research on long inputs points the same way: Chroma’s July 2025 study of 18 models found that performance becomes less reliable as input length grows, even on simple tasks. A sub-agent reads in a separate window and returns only what matters; the main agent never sees its working notes.
One workshop demonstration shows the effect on a small scale. With one agent doing all the reading, the main context held about 75,000 tokens at the end of the task; with two sub-agents doing the reading and returning summaries, it held about 49,000. A single demonstration is not a benchmark, and the saving was modest because the material was light. It grows with the amount of reading delegated.
When a client asked me why he should not use a sub-agent every time, my answer was that he basically should: any research or analysis step is a candidate. I hold the idea back in the first weeks of coaching only because it is a lot to absorb at once. Cost is the trade-off. A task that takes 100,000 tokens with one agent can take half a million with three sub-agents. Where quality matters, trading dollars for quality usually pays.
Build sub-agents into the skill rather than relying on anyone to remember them. A skill can instruct the agent to use sub-agents, so the person running it never has to ask. Skills also combine this way: one main skill calls several smaller skills, each in its own sub-agent, and assembles the results. Aim for as few skills as possible doing as much work as possible.
One client project shows the pattern end to end. A site-grading tool for energy development scores a candidate location on seven criteria, including distance to gas infrastructure, fiber access, tax abatements, community sentiment, nearby data centers, and water. In a live run, the main skill started seven sub-agents, one per criterion. Each did its bounded research and returned a score with evidence, and the main agent assembled the report: seven clean contexts instead of one overloaded one. Treat each sub-agent as a capable intern on the first day. Brief it tightly, send it to read, and take the summary.
#2Scale two: a dispatcher across people
Sub-agents fan out within one person’s task. A dispatcher fans out across people, and it is what lets one agent system serve a whole team without everyone sharing one machine.
- Who is asking?
- Load their brain
- Drop duplicates
- Run scheduled jobs
Runs with Partner A’s brain and credentials
Runs with Partner B’s brain and credentials
Runs on a timer with the team brain
Brain repositories · Session history · Schedules · Secrets
A failed request dies in its own runtime. Nothing it breaks reaches the others, and no state is lost, because state never lived there.
Picture a hub and spokes. Several inbound channels (Slack, email, text messages) feed one dispatcher, whose job is narrow: work out who is asking, load that person’s brain, drop duplicate messages, and run scheduled jobs on time. It hands each request to an isolated runtime, a computing environment that holds only that person’s context and credentials. One partner’s request runs in one runtime, a second partner’s runs in parallel in another, and a scheduled morning brief runs in a third. None of them can interfere with the others.
Compare the usual starting point: one always-on process that does everything. A single restart there kills the reply in progress, the queue, and the scheduled job at once, and every request waits in one shared queue. Isolation fixes both problems by construction. A failure stays inside one runtime. State survives any runtime because it lives outside all of them, in the brain repositories and in dedicated stores for sessions, schedules, and secrets. Response times stop depending on whoever else is busy.
Routing is where the brain and the machinery meet. A brain is just files in a repository, and each brain’s AGENTS.md tells the agent where its tools and data live; the runtime is the body the dispatcher provides for the work. Keeping the two apart is what makes the system scale. Adding a person means adding a brain repository and a routing entry, not changing the architecture.
#3Where routing meets privacy: credentials, not code
When a dispatcher routes a request, it also decides whose personal context and whose credentials load. That decision is the privacy boundary, and the mechanism is deliberately blunt.
Partner A
Partner B
Partner A’s email token
Partner B’s email token
identical code for every caller
Reads and drafts in Partner A’s inbox only
Reads and drafts in Partner B’s inbox only
Code is shared; credentials are not. Neither partner’s agent can reach the other’s inbox.
In this design, the dispatcher reads the caller’s identity, fetches that person’s tokens from a secret store, and hands them to the runtime before the agent starts. So the same email skill drafts as Partner A when Partner A asks and as Partner B when Partner B asks, and neither can draft as the other. Code is shared; credentials are not. I put it to clients this way: the agent you talk to is yours, scoped to your inbox and your files, and it cannot open a colleague’s notes.
Threads need one more rule: one thread, one brain, one default mailbox. If a second person joins an existing thread, only the caller identity changes; the thread keeps its loaded brain and its default mailbox, so a reply cannot quietly switch to someone else’s context. Credential scoping is the first privacy boundary, not the last. Finer-grained permissions on shared data are a further layer on top of it.
#4Scale three: agents as critics
A third reason to run many agents is trust rather than throughput: you fan out to check the work, not only to do it.
Produces the work
Deep in its own context, and blind to its own blind spots.
Grades it cold
Fresh context catches what the author can’t. Anything it catches goes back for revision.
A fresh reviewer catches what the author cannot see. Its value comes from a different vantage point, not a stronger model.
After the worker agents produce something, a separate agent with a fresh context reviews it before a person sees it. Our own slide-building skill starts several critic sub-agents, each judging one dimension, such as factual accuracy or layout. A due-diligence tool we built for a client follows the same recipe: parallel sub-agents, each scoped to one type of file, then a verifier agent that cross-checks their findings before anything goes back to the executive. Anthropic’s December 2024 guidance on building agents describes the same patterns: parallel model calls that each evaluate a different aspect of the work, and an evaluator-optimizer loop in which one call generates a response and another critiques it.
One caveat from practice: a committee of critics can drift toward the most risk-averse, blandest answer. A critic is a second opinion, not a substitute for judgment.
#5When coverage matters: brute-force fan-out
Sometimes the work cannot be decomposed in advance, and a single agent quits early. In our experience, an agent asked to review everything relevant across email and Slack covers much of the email, perhaps half of Slack, and then stops.
A blunt fix works: assign one agent to each source and require each to finish. It costs more and is less elegant, but when coverage matters more than cost, ten agents that each finish beat one agent that quietly gives up. A coordinator can also send each piece to whichever model suits it best; nothing requires one model to do everything.
#6Where this connects
In our curriculum, sub-agents extend Part 3 (skills): combining skills means using sub-agents, and the step after a first skill is to write sub-agent use into the skill. A dispatcher with isolated runtimes is the machinery behind Part 5 (managed architecture), and per-person routing with per-person credentials is how Part 6 (the institutional brain) serves many people from one shared brain without leaking context.
In the research track, Brain Design: L1, L2, L3 covers which context loads for each request, and The Messaging Layer covers the channels that feed the dispatcher. Olito’s own agents run on this architecture, including OliMed, our agents for independent physician practices.
Spend more parallel compute and keep every context clean. Inside a task, sub-agents read in another room and bring back a summary. Across people, a dispatcher sends each request to an isolated runtime that fails alone. One agent is where you start, not where you stop.
More from our research.
Working on the same question?
We look for people to interview, data to compare against, and teams willing to test what we find. Leave a note and we will write back.