I counted the tools in one agent session. There were 349 before I said hello.

The measured cost of "connect everything" — and why the fix is already quietly shipping.

I spent this afternoon in an ordinary agent session — a connected assistant with the usual pile of integrations switched on. Out of idle curiosity, before I gave it a single instruction, I counted the tools it had access to. Three hundred and forty-nine. A stock-trading API alone accounted for fifty-two of them. Two project trackers, a browser, a design app, file storage, a calendar. Almost none of it had anything to do with what I actually needed.

Then I did the arithmetic on carrying all of that as raw context. Anthropic published a concrete breakdown for exactly this: a five-server setup — GitHub (35 tools, ~26K tokens), Slack (11, ~21K), Sentry, Grafana, and Splunk — comes to 58 tools and roughly 55,000 tokens before the conversation begins. Add a Jira server, which runs about 17,000 tokens on its own, and you clear 100,000. At that rate, my 349 tools would be north of 300,000 tokens of schema — more than fits in most context windows. Which is the first clue that "just connect everything" was never actually free.

Here's the good news, and it's the crux of this piece: my session didn't load all 349 raw. It deferred them — kept a lightweight index and pulled the three or four tools each task needed on demand. That deferral is not a footnote. It's the entire fix, and the fact that it now ships inside serious agent stacks tells you the "load it all" era is ending. The bad news is that plenty of setups still load everything, and the bill is worse than they think.

The token math

I tokenized a handful of the real tool schemas myself, using the same encoding these models use. A simple read tool: 209 tokens. A mid-size one: 295. A heavier one: 446. That squares with Anthropic's figures — once the big write tools are counted, real catalogs average close to a thousand tokens per tool. Either way, a few dozen tools is a short novel of JSON the model has to read before it can read you, and it pays that cost on every single turn, not just the first.

The tax you actually feel

If it were only tokens, you could pay it and move on. It isn't. The expensive tax is accuracy.

Anthropic's own account is blunt: reliability starts to fray somewhere around twenty tools, and selection accuracy falls as the catalog grows — worst of all when tools have similar names or overlapping jobs. That last part is the quiet killer. My session's trading server by itself offered get_equity_quotes, get_option_quotes, and get_index_quotes — three near-identical names, three chances to grab the wrong neighbor, and that's one server out of a dozen. Choosing the right tool is a needle-in-a-haystack problem, and every integration you bolt on is more hay.

So the catalog charges you twice: once in tokens, once in judgment. The second one is the killer, because a wrong tool call isn't a slow answer. It's a confident wrong one.

The "just in case" fallacy

Catalogs balloon because "keep it loaded in case we need it" sounds prudent. But an agent that can trade stocks, run your calendar, and edit a design in a single session is not versatile. It's unfocused, and it pays the premium on all three every turn whether it touches them or not. Optionality you exercise two percent of the time is not a feature. It's a standing charge — and it demos beautifully while running badly, which is the worst combination, because the demo is the part that gets funded.

What good looks like

The fix is not a smaller world. It's loading the right small slice of the world per task.

• Defer the catalog and search it on demand. Mark tools as deferred, keep them discoverable, and load only the handful a task calls for. Anthropic reports this cuts tool-definition tokens by about 85 percent and, tellingly, raises accuracy — one internal benchmark jumped from 49 to 74 percent with it switched on. My session was already doing exactly this, which is why the 349 tools didn't sink it.
• Scope toolsets to the job. A triage task gets triage tools. A deploy task gets deploy tools. The union of everything is not a workspace; it's a liability.
• Measure before you connect. Reliability frays past roughly twenty tools, so treat each new server as a cost, not a free win. Count the tokens before you flip it on.

The part nobody profiles

The tool catalog is the one component of an agent that never shows up as a slow function or a failed request, so nobody watches it. It's invisible overhead — a tax on every single turn that grows a little each time someone enables one more connector because it seemed harmless. It is harmless the way one more subscription is harmless. Then you read the statement.

I'm not preaching austerity, and I'm not selling you a diet. I'm asking you to look at the number. Open your agent, list the tools it's actually carrying, and run the schemas through a tokenizer. It takes ten minutes. If the result surprises you, that's the whole point — it surprised me, and measuring this sort of thing is literally my job.

Disclosure: OBTO builds agent infrastructure, so we have a horse in the "fewer, sharper tools" race. The tokenizer doesn't care whose platform you're on. Go run it on your own stack.