The number that travelled was twenty thousand dollars in a single month.
The number that should hold your attention is one. One handwritten paper list, keeping track of fifteen concurrent AI agents.
Ryan Carson, a solo founder, described the setup on Lenny's Newsletter. Fifteen Devin agents running at once across engineering, customer success and investor updates, organised through a folder system and a list on paper rather than any kind of dashboard.
The paper list is the finding
When the orchestration layer of a fifteen agent operation is a sheet of paper, you have learned something specific about the state of this market.
The tooling for managing agent fleets does not exist yet. Not at the level where a person can answer, on demand, what all fifteen did yesterday and which two of them were quietly wrong.
So the compute is industrial and the management is artisanal. That gap is the actual bottleneck, and every company adding agents this year is going to rediscover it independently.
The models scale beautifully. Supervision does not scale at all, because supervision is bounded by one human's working memory and attention.
My working estimate from watching teams deploy these systems is that the ceiling sits somewhere between five and twenty agents per supervising person, depending entirely on how verifiable the output is. Code with tests sits at the high end. Anything requiring judgement about a customer sits at the low end.
Nobody has published a real number for this because nobody is measuring it. Carson's paper list is the closest thing to an honest data point I have seen this year.
What twenty thousand dollars buys
Fifteen agents at that spend is roughly a junior team's monthly payroll in a lot of markets, without the recruiting cycle, the notice periods, or the onboarding.
That is the genuine argument, and it is strong. It is also incomplete in a way worth naming.
Carson built what he calls a watchdog playbook, an automated monitoring system covering every law firm account, replacing work a customer success team would have done. That is agents operating at account level rather than task level, which is the interesting frontier.
But his own conclusion cuts against the throughput story. Producing more output does not make a better product, as he and host Claire Vo both land on.
The thing that changed his product direction was meeting actual customers, away from the computer.
So in a fifteen agent operation, the highest leverage input of the month was the single activity that no agent performed. Sit with that before you approve a fleet budget.
Three tools, three jobs
One detail that looks like indecision and is actually insulation. Carson runs Devin for primary development, Codex for specific situations, and converts design output into Markdown specs.
Different tools for different jobs, with the interface between them being plain text that any of them can read.
That is the practical version of not letting one vendor own your agents. The specs live in a format nobody controls, so the agent underneath is replaceable when pricing changes or quality slips.
Teams that build the opposite way, one vendor holding the specs, the memory and the execution layer, will find out what that costs at renewal.
Wrong output looks exactly like right output
This is the property that makes agent supervision different from managing people, and it is badly underrated in every deployment plan I read.
A junior colleague who is out of their depth signals it. They ask a question, they hedge, they take longer, they escalate. Those signals are the mechanism that lets management scale at all.
An agent produces confident, well formatted, complete work whether or not it understood the task. There is no hesitation in the output, because there is no hesitation in the system.
So the verification cost per unit of output stays roughly constant while the volume of output does not. That is the entire scaling problem in one sentence, and it explains why the fifteenth agent consumes more attention than the first.
The question to answer before you scale
Before adding agents to any workflow, write down two things.
Who checks their work, by name. And how you will find out when one of them is confidently wrong, given that a wrong agent produces output that looks exactly like a correct one.
If the honest answer to the second question is a paper list, that is fine. Paper works. But know that it is a paper list, and know that it caps your fleet at whatever one person can hold in their head on a bad Thursday.
This is the same wall behind the wider story of one person now running the whole stack. The stack is one person wide because the supervision is, not because the software is.
The economics here are genuinely good, which is why the coordination problem matters. Cheap capacity you cannot verify is not capacity, it is exposure.
The agents are cheap. Knowing what all of them did yesterday is not.