House martins fly out from a row of mud nests under the eaves of a barn, and return to them.

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.

A sub-agent is one more toolIllustrative word counts
Main agent

Holds the thread of what you want

  • Read files
  • Run code
  • Search the web
  • Start a sub-agent
Sub-agent · fresh context window

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.

Added to the main agent’s context
Main agent reads the material itself50,000 words
A sub-agent reads it and reports back5,000 words

Only the summary comes back, so the main agent’s context stays small and on task.

A sub-agent is one more tool: a fresh context window that does the heavy reading and returns a short summary. Word counts are illustrative.

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.

Many doors, one dispatcher, isolated runtimesAcross people
Doors
Slack
Email
SMS · iMessage
Dispatcher
  • Who is asking?
  • Load their brain
  • Drop duplicates
  • Run scheduled jobs
Isolated runtimes, in parallel
Partner Arequest

Runs with Partner A’s brain and credentials

Partner Bsame moment

Runs with Partner B’s brain and credentials

Morning briefscheduled

Runs on a timer with the team brain

Durable state, outside every runtime

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.

Many doors, one dispatcher, isolated runtimes. Each request runs with its owner’s brain and credentials, and durable state lives outside every runtime.

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.

Privacy lives in the credential, not the codeSame skill, different reach
Caller

Partner A

Caller

Partner B

dispatcher fetches from the secret store
dispatcher fetches from the secret store
Loaded at start

Partner A’s email token

Loaded at start

Partner B’s email token

Email skill

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.

Same skill, different reach: the dispatcher loads each caller’s own credentials before the agent starts, so identical code reaches only that person’s data.

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.

Reviewer sub-agentsA different agent grades the work
Author agent

Produces the work

Deep in its own context, and blind to its own blind spots.

Reviewer sub-agent

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.

A reviewer sub-agent, with a fresh context and no stake in the first agent’s choices, grades the work before it reaches a person.

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.