Running ten agents broke my brain
A real story about scaling up parallel coding agents, crashing hard, and the tool I built after working out why.
Managing multiple parallel AI agents is a learned skill, not a switch you flip.
I scaled up gradually to running around ten agents at once, stopped for three weeks, and came back only able to handle two. The interest was still there. The skill was gone, the same way an athlete loses fitness after time off.
I'm calling this agentic cognitive overload, ACO, and I don't think it's just me. There's a real problem with how people are using AI agents right now, and if you don't stop and look at what you're doing, the way I eventually had to, it will cause you problems further down the line.
How I got to ten agents
The odd part is that I'd been building AI products for a while, tools, a whole platform, before I let AI anywhere near my own code. That started around early-to-mid 2024, with Cursor, and the flow was the same one I'd always had: pick up a ticket, work through it, AI writing some of the code and helping me brainstorm the harder bits. It got better and better. Eventually AI was writing around 80% of the code and I was doing the other 20%, the complicated UI work and the logic I couldn't quite hand over. Still one ticket at a time, at a push two, because Cursor made anything more than that awkward.
Then, around the end of 2025, Opus 4.5 came out and the models were suddenly unbelievable, properly heading towards AGI territory. I'd heard the Claude Code CLI handled multiple agents far better than Cursor did, so I gave it a try.
Nobody decides to run ten agents. You drift there one comfortable step at a time. First a couple of agents on the same project. Then multiple worktrees, so they could work on different things in the same repo without treading on each other. Then multiple windows. Then different projects entirely, agents all over the place, all running at the same time. Every step felt small, and every step worked, so I took the next one. At the peak I had around ten agents on the go at once, and I was getting loads of stuff done.
Then I stopped, and couldn't cope
In February I had to move house. Pack everything up, move, unpack, do a bit of decorating. For two weeks, maybe three, I didn't write a line of code.
When I got the computer set back up and tried to start again, I couldn't run more than two agents. My brain genuinely couldn't cope with the volume of information. I just couldn't do it. Three weeks earlier this had been an ordinary working day.
That's when it clicked. I had trained my brain to do this, gradually, without ever noticing the training, and three weeks off had undone it. Building back up took many more weeks, and I never fully got back to ten.
Like an athlete who stops running for six months and then tries to race, the ability doesn't just switch back on because you want it to.
And a way of working you can lose that fast is probably not a good way of working. I don't think it was doing my brain, or my psychology, much good even when it was going well.
Every window wants an answer
So I sat down and worked out what had actually been going on in those ten-agent days.
Run one Claude Code window and you get a constant stream of text: the agent's reasoning, its plans, its diffs, all flowing past as it works. Alongside the stream sits a queue of questions only you can answer. Approve this? Is it building the thing you actually asked for? Which worktree is it in? Do you test this by running the suite or by clicking through the screen yourself? Did the change apply? Is it ready to merge, and into what?
That's one agent, and it's manageable. Now run ten. Ten streams of reasoning scrolling at once, ten queues of those questions, all live, and every answer has to come from the same brain, because you're the only human in the loop. Nothing gets triaged and nothing waits.
Working like that means being switched on every second you're at the desk. From the inside it felt like productivity. It took three weeks of packing boxes for me to see it as load.
Naming the problem
I don't think this is unique to me, and I don't think it's unique to coders. Anyone running multiple streams of AI work at once is heading for the same wall: an overload of information, constant approval and review across every stream, no real way to manage the volume.
The tools have made it easy to open ten streams of work long before anyone has asked what ten streams does to the person in the middle. Most people are still on the way up the curve I was on, which is why I think this is a common problem that mostly hasn't been noticed yet. So it gets a name: agentic cognitive overload, ACO.
It needs a name before it can be solved.
What I built about it
So I built Mission Control: a layer that sits on top of Claude Code and other CLIs, and lets me manage a whole team of coding agents through a UI, following standard patterns rather than raw terminal juggling. In practice I deal with one or two agents whose job is managing the rest of the team. The worker agents still stream their reasoning, their output still gets checked, tested and merged, but that load lands on the manager agents rather than on me. I get the decisions. They get the noise.
The agents in that diagram are permanent. Each of the eight has a name, a role and its own memory, carried from one session to the next: Io coordinates the team, Hopkins runs growth, and both will be there tomorrow remembering what they did today. Nothing gets spun up for a task and binned afterwards. I didn't say this in the video, but it's how I hold the whole thing in my head. I think about the team the way I'd think about a human one, named people in named roles, and that's a shape my brain already knows.
The point is being able to work at a more normal pace, without being switched on every second, because I think staying that switched on eventually costs you. It works really well for me, which for now is a sample size of one, so I'm open-sourcing it. Over the next few weeks I'll be introducing the concepts behind it properly, with the aim of getting it into your hands.
This is the same team, running the same way, that builds and runs Inkie day to day. Mission Control is what makes that team manageable; Inkie is what the team actually ships.
A few common questions
What is agentic cognitive overload, exactly? The wall you hit when parallel AI work outruns your ability to track it: several agents streaming reasoning at once, each with its own queue of approvals, checks, tests and merges, and no real way to keep on top of the volume. I hit it going from one agent to about ten, then stopping for three weeks.
Why didn't the skill come back the moment I sat back down? Because it was trained into me gradually, and the break untrained it. Like an athlete who stops running for six months, you don't just decide to race again. Rebuilding took me many weeks, and I never quite got back to ten.
Is running ten agents just a bad idea, then? Raw, across ten terminal windows, probably yes. It worked for me for a while, but a working pattern you can lose in three weeks, and that needs you switched on every second, is probably not doing your head much good. The fix I landed on is tooling that keeps the volume and takes the strain off.
What does Mission Control actually manage? It sits on top of Claude Code and other CLIs and runs a whole team of agents through a UI, with one or two manager agents dealing with the rest. I talk to the managers; the streams and the checking land on them.
Is Mission Control open source yet? Not yet, but it's coming. I'll be introducing the concepts behind it over the next few weeks, working towards getting it into your hands.
It's coming for you too
If you're running multiple streams of AI work, agentic cognitive overload is on its way to you as well, whether you've noticed it yet or not. You can wait for your own three weeks of packing boxes to show you, or you can look at how you're working now.
Go out and make some cool shit, but do it carefully, and think about your own mind while you're doing it. Take it easy.