In Goethe’s poem “The Sorcerer’s Apprentice,” the apprentice waits for his master to leave, then casts a spell on a broom to haul water for him. At first it’s marvelous — the broom carries the buckets on its own, and the apprentice just folds his arms. The trouble is, he never learned the spell to make it stop. The broom won’t quit, and when the frustrated apprentice splits it with an axe, it becomes two brooms hauling water twice as fast. Only after the room is flooded does the master return and halt everything with a single word.
I’ve stood in that apprentice’s place twice over the past year of hand-building a personal AI assistant — first when I kept several agents, then when I moved the tool the assistant lived in. Both times I loosened the reins because it was thrilling, watched control slip out of my hands, and got it back only after retreating from the flashy version to the plain one. I called it a retreat at the time. Looking back, it was taking control back.
Act 1 — I Thought More Agents Would Mean More Smarts
Once I had a personal assistant, one agent soon seemed not enough. An agent for writing, an agent for finding sources, an agent for the calendar… and I didn’t stop there. I gave each one a name and a temperament — this one careful, that one bold. I handed out roles, and even gave each its own memory to keep. Let them remember their share of the work, divide it up, and confer among themselves, and isn’t that running a little team? That was the thought.
At first it really was something. Without my prompting each step, the ones I’d named called to each other, passed messages back and forth, split the work, merged the results. It felt like watching a small meeting unfold on screen. It was magic — right up to the demo.
When the Squad Scatters
Run it a little longer, and the little team turned into a broom that wouldn’t stop.
I couldn’t trace who did what, or why. When a result came out wrong, there was no retracing which agent made which call where. With five moving in five directions at once, one person can’t hold all five threads in their head. It can’t be supervised.
They moved on different premises. The assumption agent A worked from and the one agent B worked from were out of sync — and neither knew the other’s. Cognition, the company behind Devin, put its finger on exactly this in an essay titled “Don’t Build Multi-Agents.” Actions carry implicit decisions, and conflicting decisions carry bad results. When each acts on assumptions that were never aligned up front, the combined result breaks.
The overhead grew. Each agent is something to look after — its own role, its own instructions, its own state. Five of them means five times the upkeep. The help I brought in to lighten the load made more of it.
A fuzzy purpose sent it off the rails faster. A team of people drifts when the goal is vague too, but with an agent it’s worse: it never stops midway to ask, “wait — is this the right direction?” A tenth of a degree off at the start, and it runs that exact angle all the way to the end. Once, a discussion that began from a perfectly sound question had, a few exchanges later, arrived at a strange conclusion nobody had asked for.
And chattering nonstop, they burned tokens to ash. They rarely stopped talking. One would ask, another would answer, and that answer raised a fresh question. A conversation a person would cut off with “all right, that’s enough,” they carried on among themselves without end. And every line of it cost money. Like the broom that doesn’t know the word to stop, the talk kept multiplying and the tokens burned down with it. I’d handed over one line of work; the bill came back a paragraph long.
So I Cut It Down to One
In the end I came back to a single agent. One agent, but with several tools in that one hand — to search, to read files, to edit code. Then every call gets made inside one continuous context, and I can read that single thread from beginning to end. If a result is off, I can see where it went wrong; if the direction drifts, I can catch it on the spot.
Cognition’s recommendation lands in the same place: don’t carve context into pieces and parcel it out — share it whole, and the most reliable form is a single agent running as one thread. My experience came first; their essay explained the reason afterward. From many to one — that was the first retreat.
So Are Multi-Agents Wrong?
That doesn’t mean multi-agents are always wrong. There are clearly places where they shine.
The multi-agent research case published by Anthropic, the maker of Claude, is a good counterexample. With one lead agent parceling out searches to several sub-agents, it outperformed a single agent by more than 90%. But there’s a condition. What worked was parallel, read-only search across several independent threads at once. For spreading wide to gather information, more is decidedly better — the threads have nothing to collide over.
The cost is known, though. In the same piece, Anthropic noted that a single agent alone already burns nearly 4 times the tokens of an ordinary chat — and a multi-agent system roughly quadruples that, to about 15 times in all. So it only pencils out for high-value work that justifies the spend.
And the places multi-agents break are just as sharp. Work where the agents must share the same context, work where the tasks are tangled together, work where judgment has to run as one thread. Everyday work, and most coding, actually sit here. What my personal assistant did sat squarely here too. So multi-agents just didn’t fit my case — which isn’t the same as saying they’re bad.
The dividing line shrinks to one sentence. Splits wide, go many; runs deep, go one. My work ran deep.
Act 2 — Moving Where the Assistant Lives
Only after I’d straightened the agent into a single thread did I notice where that assistant actually lived. Until then it had been running on a messenger — Telegram, Slack, that sort of thing. The reason I’d put it there was simple: zero barrier to entry. The app is already installed, I can talk to it straight from my pocket, and bolting on a bot takes half a day. I’d type “sort out today’s schedule” into the chat window and an answer came back.
But after living there a while, three walls showed up.
First, on mobile chat it’s hard to look back over what’s piled up and manage it. Chat flows. What I carefully sorted out yesterday has drifted up past the scroll today, and finding it again means climbing back a long way. The record is kept somewhere, sure — but laying it all out at a glance, sorting it, picking through it: that doesn’t happen in a single-file conversation stream, least of all on a small phone screen.
Second, you can’t hold many kinds of work in one place. I wanted my notes, my to-dos, my investment dashboard, and the day’s diary all together. But a messenger bot can talk; it can’t build a screen. Splitting into tabs, standing up lists, drawing a table — none of that works inside a chat window.
Third — and this is a different kind of thing — you’re tied to a platform. A messenger isn’t something I built; it’s one company’s service. If the API policy changes, if a fee appears one day, if the bot rules tighten, my assistant is at their mercy. My data sits on their servers, and I don’t even get to decide the shape of the window I pass through every day. This is what people call app dependency, or lock-in.
So I built a small web app myself. It isn’t flashy. Next to the polished finish of an off-the-shelf messenger, it’s crude. But where the data piles up, how the screen is divided, what tools it connects to — I decide all of it. That was the second retreat: from a well-made off-the-shelf app to a crude tool of my own.
Not long ago, building a web app yourself was unthinkable. Laying out the screen, standing up a server, deciding where and how to store the data — moving all of that into code by hand took days. Now an agent does that work for you. Describe the shape you want in plain words, and the single agent comes back with the screen and the code. The effort of building drops so far that building it yourself is no longer reckless. The one agent left after the squad was disbanded had, this time, built me a house.
But something new became mine to carry in return: security. An off-the-shelf messenger handled the login, the data protection, the work of keeping others from peering in — the company took care of all of it. In the house I built, I have to lock those doors myself. Who can get in, whether my data leaks out, whether there’s a door I left open without thinking. And the faster the agent writes the code, the more closely I have to look at whether that code is actually safe — because what comes out fast brings its gaps along with it. As much as building got easier, keeping it safe became a new weight to carry.
Both Retreats Say the Same Thing
Disbanding the squad and leaving the messenger were, looking back, two faces of the same realization.
Novelty shines in the demo and cools in the running. Agents chattering among themselves, a do-everything bot — both look impressive the first time you show them off, but neither is something you can lean on every day. Smarts that’s beyond your control is nothing you can trust.
Strip away the flash and three things were left: ownership — the data and the screen are mine; purpose — knowing exactly what the tool is for; and control — being able to follow what happened and why, all the way through. What two attempts at building bigger and smarter taught me is that coming back to only as much as fits in your hand isn’t a retreat. The apprentice’s broom was frightening not because it hauled water, but because it was let loose without the word to stop it. When the hand that holds control came back, the broom became a tool he could wield again.
The idea that you can hand off the doing but not the understanding continues in You Can Delegate Thinking to AI, But Not Understanding; how agents reshape the very form of an organization continues in The Taxonomy and Evolution of Org Structures.