You Don't Need Fewer Agents. You Need Agents That Don't Need You.
Addy Osmani named the orchestration tax. The fix isn't fewer agents. It's agents that close their own loop.
A few weeks ago I caught myself with fourteen terminal tabs open, each one an AI agent doing something. One was refactoring a script. One was drafting a newsletter. One was digging through support tickets. Two were stuck waiting on me and I had forgotten which two.
It felt like a whole team was working for me. I was also exhausted by noon. Both of those were true at the same time, and it took me a while to admit they had the same cause.
I was the thing all fourteen agents were waiting for. And there is one of me.
Addy Osmani gave this feeling a name
Addy Osmani wrote a piece this week called The Orchestration Tax, and it put a clean edge on something I had been feeling without language for it. The argument is simple. Starting an agent is cheap. It is a sentence. Closing the loop on that agent is expensive, because someone has to read what came back, decide if it is right, and reconcile it with everything the other agents touched. That someone is you. There is one of you.
He borrows the best metaphor for it from programming. Python has a Global Interpreter Lock, the GIL. You can spawn a hundred threads, but only one runs real work at a time, because they all have to grab the same single lock. You are the GIL of your agents. They can all run. But the moment any of their work needs judgment, that work has to wait for the one lock. You hold it. You are the slow serial part of a fast parallel system.
He got there on a Google I/O panel with Richard Seroter, Aja Hammerly, and Ciera Jaspan. Richard is the one who named it. "You can't manage twenty agents successfully in your own brain." He is right. Feeling busy and being productive came apart for me the same way they did for Addy.
Read his piece. It is the best diagnosis of this problem I have seen.
But I think most people are about to draw the wrong conclusion from it.
The wrong lesson is "run fewer agents"
The obvious takeaway is to throttle yourself. Scale your fleet down to the number of agents you can personally review, which for most of us is two or three. Slow the producer to match the consumer. Backpressure.
That is good advice for the agents you have today. It is the wrong thing to optimize.
Here is the part the GIL metaphor hides. The tax is not paid per agent. It is paid per open thread to your attention. An agent you babysit in a chat window holds a thread open the entire time it works. Every turn, it stops and looks at you. Twenty of those is unmanageable, and Addy is completely right that it is. But the count was never the real problem. The architecture of each agent was.
Most of what people call "running agents" is sitting in a terminal tab, watching an agent think, approving each step, nudging it when it drifts. That is not delegation. That is pair programming with something that types faster than you. Of course it does not scale. You did not remove yourself from the loop. You just moved your chair closer to it.
The fix is not fewer of those. The fix is to stop building those.
Two species of agent
There are two completely different things wearing the word "agent" right now, and we keep talking about them as if they were one.
The first is the assistant in a terminal tab. You prompt, it responds, you steer, it responds again. It is brilliant for hard, fuzzy work where the judgment is the whole point. It is also a continuous claim on your attention. You cannot walk away. The loop only closes when you close it, by hand, every time.
The second is the autonomous agent. It is not a conversation. It is a thing you wrote down once. It runs on its own, does its job, checks its own work, and only comes back to you at one gate you decided on in advance. When it is not at the gate, it holds zero threads to your attention. You can have ten of them running and feel nothing, because none of them is sitting in a terminal tab waiting for you to look.
Addy himself pointed at this. In his five fixes, four are about rationing your attention better. Sort the work. Batch the reviews. Protect your serial time. Give agents a long leash. All good. All discipline. The fifth one is different in kind: only spend the lock on judgment, and make the agent prove the boring eighty percent itself with a passing test or a screenshot.
That fifth one is the only structural fix in the list. The other four help you survive the tax. The fifth removes the work from your lock entirely. So I would bet everything on the fifth and treat the rest as coping.
The autonomous agent is what the fifth fix looks like when you build a whole thing around it.
What that actually looks like
I write mine with AgentUse. An agent there is not a chat session. It is a markdown file. You describe the job in plain English, list the tools it can touch, tell it how to verify its own work, and set one approval gate for the single decision that needs you. Then you give it a schedule, and the thing runs itself.
One I use every week reads our newsletter performance, the recent subscriber replies, and the support themes from the last seven days. It drafts a brief. It checks the brief against the last few sends so it does not repeat an angle we already used. Then it stops at one gate and shows me the draft and the reasoning. I spend ninety seconds on the only part that needs me, which is the judgment call. The hour of reading, cross-referencing, and reconciling that used to be mine never enters my lock at all.
Compare that to the terminal-tab version of the same task. I would open a session, paste the data, watch it work, correct it twice, ask it to check itself, and close the loop manually. Same output. But one of them taxes me for an hour and one of them taxes me for ninety seconds, because one holds a thread open the whole time and the other holds none until the gate.
Think of a space heater with no thermostat. You are the feedback loop. You keep getting up, feeling the room, twisting the dial, sitting back down, getting up again. A thermostat is the same heater with the loop closed inside it. You set the target once. It only interrupts you when something happens that it cannot handle on its own. Most people are running their AI like a space heater and calling themselves busy because they never stop walking to the dial.
AgentUse, or whatever you build this with, is how you put the thermostat in.
Why this beats Amdahl instead of obeying it
Amdahl's Law says your speedup is capped by the part of the work that stays serial. Addy is right that in agent work, the serial part is your judgment, and spawning more agents does not speed up your judgment. It just deepens the queue feeding into it.
But you do not beat Amdahl by adding cores. You beat it by shrinking the serial fraction. That is the whole game.
A terminal-tab agent has a fat serial fraction, because reading raw output, deciding if it is right, and reconciling it are all yours. An autonomous agent that writes its own passing test and hands you a verified result has a thin one, because the verification moved out of your lock and into the machine. You are no longer reviewing whether the work is correct. You are reviewing whether the correct work is the right work. That is a smaller, sharper question, and it is the only one worth your attention anyway.
So the backpressure ceiling Addy describes is real, but it is not fixed. Raise your effective review rate by making most of the work arrive pre-verified, and the ceiling moves up. You can run more agents, not fewer, because each one now asks less of you. The constraint was never the count. It was how much of your lock each agent demanded.
The version of this in your own life
I wrote a while back about open-loop and closed-loop companies, the ones that forget versus the ones that compound. This is the same idea pointed at a smaller target. A terminal-tab agent is an open loop you have to close by hand every turn. An autonomous agent is a closed loop that produces its own verification and only escalates the judgment.
The same split runs through a life, especially past forty, when the number of things you are trying to keep moving at once stops fitting in your head. Work, health, money, family, the project on the side. You can try to hold all of it in attention at once, checking each one, twisting each dial, feeling busy and getting nowhere because every loop stays open and waits on you.
Or you close the ones that can be closed. The weekly review of your training and your spending and your goals does not need you to assemble it. It needs you to read it and decide. An agent can do the assembly and stop at the one gate that is actually yours. What is left for you is judgment, which is the only thing you were ever good for in that loop anyway.
A 45-year-old running fourteen open loops by hand feels exactly as busy as I did with those fourteen tabs. And gets about as far.
One thing to do this week
Find the one agent you babysit the most. The chat session you keep reopening for the same recurring task. The one that taxes you every single time because you are its loop.
Write it down as a file instead. Describe the job, give it the tools, tell it how to check its own work, and set one gate for the part that needs you. Run it once by hand to see if it holds. Then put it on a schedule and walk away.
You will not have one fewer agent. You will have one fewer thread pulling on the one resource you cannot clone.
That is the whole move. Spawning agents is not the skill. Anyone can open twenty tabs. The skill is building the ones that do not need you to be standing there, so the only thing you spend your attention on is the thing only you can do.