Most of what I have written so far is theory. Then we tried it on the ground.

The first question I hear from everyone is the same. Why bother with multiple agents at all? Why not one big agent that does everything?

It is a fair question. The intuition is that a model with a million-token context window should be able to hold the whole job in its head. The intuition is wrong.

Tool calling burns context. Every tool a model can call is a chunk of context it has to read. Every nested file structure is more context it has to navigate before it can do anything. The accuracy of tool calling drops as the nesting gets deeper. By the time you have given a single agent access to enough tools to do every job, most of its context window is spent on overhead. There is barely any room left for the actual conversational flow of getting things done.

The right architecture is the opposite. Small agents with limited tool surfaces. Each one keeps most of its context free for the work. They hand off to each other when the work needs something they do not have. That is how humans operate. Nobody keeps the world in their head. You ask the person sitting next to you.

We tried to ignore this. The first project was an executive assistant. One agent in front of you, holding your calendar, your inbox, your messages. It mostly worked. People liked it.

Then we kept adding. SEO tasks. CRM maintenance. The context that a product manager needs to do their job. The context a sales person carries in their head. Each new domain came with new tools, new files, new history. We loaded all of it into the same agent.

It broke. Not all at once, just gradually. The agent would forget what it had said two days ago. It would mix up which person's CRM record it was looking at. It would call the wrong tool at the wrong moment. The bigger we made its context, the worse it got at the small things.

The lesson was that there is no version of this where one agent holds everything. Nobody can. Not a human, not an agent, not a million-token context window. The amount of context a single person's working life produces in a week is more than any model can carry. Multiply that by the people the agent is supposed to serve and you have nothing to do.

That is the problem. The whole multi-agent question is downstream of it.

The deeper lesson is numerical. There are two numbers worth tracking for any agent. How much it can hold in its head. How much it can reach for outside its head.

The first number is the context window. Everyone tracks this one. It has grown from about two thousand tokens five years ago to two million tokens in production this year. That sounds like a lot. It is also slowing down.

The second number does not have a name yet, so I will give it one. Call it the retrievable surface. It is the amount of information an agent can reach via tools. Files it can grep. Databases it can query. Codebases it can index. The web it can search. The retrievable surface is not bounded by the context window. It is bounded by what the agent's harness lets it touch.

Dividing one by the other gives the retrievable surface ratio. RSR for short. It is how many times more an agent can reach than it can hold.

In 2020, RSR was about one. There were no tools. What the model could see was what you pasted.

In 2026, RSR is about ten million. A coding agent with a million-token window can grep through a billion-token monorepo. A research agent can pull from a hundred trillion tokens of indexed web. The ratio is no longer a ratio. It is an order of magnitude that swallows the original number.

The chart below shows the split. The solid line is what models can hold. The dashed line is what agents can reach. The lines started in the same place and have not come back together since.

This is the deeper lesson from what we built. We did not run out of context window. We ran out of the right thing to put inside it. The agent kept reaching for the wrong files, the wrong tools, the wrong memories. The amount of work it had to do inside its head did not scale because the amount it could reach for outside its head was already too big to organize.

Reach is only half the story. The other half is what is actually useful when you get there.

A coding agent that can grep over a billion-token monorepo still only needs a few hundred lines for any given task. A research agent that can pull from a hundred trillion tokens of indexed web still needs maybe ten links per query. The signal-to-noise ratio of the retrievable surface is brutal. Less than a thousandth of a percent of what an agent can reach is ever useful in a single turn.

This is the failure mode you see in Claude Code every day. The agent runs grep. Gets back hundreds of matches. Reads through them. Finds nothing relevant. Runs another grep. Reads more. Finds nothing again. Three nested searches in, the context window is half full of noise. Then the model hallucinates a function name. The user has to correct it. By then there is not enough window left for the actual work, and the harness silently compresses what was already there. The user is now staring at an agent that has lost track of what it was doing, mid-task.

This happens whether the agent did great work first or did nothing at all. The compression is the same. The hallucination is the same.

So the second number that matters is not just how much you can reach. It is how many attempts you have before reaching becomes useless. Call it the search budget. Every modern agent has one. Most of them blow it on noise.

The fix is not a bigger window. The fix is better reaching. Specialized agents with smaller windows and sharper retrieval beat one big agent with a giant window every time, because they have less to ignore.

This is the bet beneath the bet. Most of the industry is racing on the wrong axis. The race that matters is the dashed line.

The dashed line gets clearer when you measure whole agent systems, not just retrievable surface.

One agent can do four to eight hours of expert work today. Two years ago it could do a few minutes. Sixteen agents working together compressed two weeks of expert engineering into two weeks of wall clock time. The single-agent curve doubles every seven months on its own. The multi-agent curve barely existed two years ago. It is the one to watch.