On 16 November I had 96 Claude Code sessions open in the desktop app. Nearly all of them were ungrouped, sitting in one long list sorted by date. I was halfway through a client engagement, the work was going well, and it still felt like chaos, because I couldn’t tell you what was in flight.
Most advice on running parallel Claude Code sessions is about running them: split panes, worktrees, a dashboard that shows which agent wants input. That’s useful, but it wasn’t my problem. My problem was keeping the thread, and that turned out to be a flow problem rather than a tooling one.
What was actually open
The first surprise was what the sessions were for. Only about 1 in 10 had a merge request behind them. The other 9 in 10 were meetings, documents, strategy work and drafts.
That matters because the standard clean-up rule for coding agents is “archive the session when the PR merges”. It’s a good rule, and it covered about 1 in 10 of my sessions. Everything else had no natural end, so it just stayed open.
If you use Claude Code for more than code, and most founders and CTOs I work with do, you’ll have the same shape. The merge is the only finish line the tooling knows about, so the rest of your work never finishes.
The real cost was overlap
The clutter itself wasn’t the expensive part. The overlap was. When I went through the list, I found two sessions working on the same diagnosis, five on one agent-building project, and four separate sprint-kickoff chats.
Each of those was a new chat opened for work that already had a session holding the full context. So I’d re-explain the background, get a slightly different answer, and now have two versions of the truth in two places. That’s the same rot I wrote about in why AI setups rot, just at the scale of a week rather than six months: context with no owner drifts.
Ninety-six open sessions isn’t a memory problem. It’s work in progress with no limit and no definition of done, which is a problem engineering teams solved years ago.
One close-out pass, two live surprises
I took one group of 10 related sessions and did a single close-out pass. Eight were done. Their output was already on main, already in the engagement record, or already published. They’d been finished for days and were still open, taking up attention every time I scanned the list.
The other two were still live, and both were things that mattered. One was a merge request that had sat with no reviewer since September. The other was a newsletter draft that had never been sent. Neither was urgent enough to shout, so neither did. Both were invisible until someone looked.
That ratio is the useful part. Most of the clutter is finished work you can close in seconds, and hidden inside it is the small amount of stalled work you actually need to see.
The false alarm
One warning before you start tidying. Part way through, a check flagged “4 uncommitted drafts at risk”. It looked like work about to be lost, so the obvious move was to commit them.
They were already on main. Worse, one of the worktree copies was an older version, so committing it would have overwritten the newer one. The rescue would have been the damage.
So before you “save” anything during a clean-up, check what’s already on main. A session’s copy of a file is a snapshot from when that session last touched it, not the current truth.
Four practices that fixed it
None of these needed a new tool. They’re the same flow habits a good engineering team runs on, applied to one person and a lot of agents.
1. One place to see everything
Group sessions by workstream, not by date or by repo. The desktop app’s sidebar groups do this already. A date-sorted list tells you what you touched last, which is almost never the question. A workstream group tells you what’s in flight on each piece of work, and it makes overlap obvious: four sprint-kickoff chats in one group stand out in a way they never do scattered through a list of 96.
2. Limit work in progress
I pin at most five sessions, and a pin means “this week”. Everything else is either done, parked in its group, or waiting on someone else.
The reason is Little’s Law, which says lead time = work in progress ÷ throughput. If I finish, say, 15 threads a week and keep 96 open, the average thread takes more than six weeks from opening to done. Hold the open count near 15 and the same throughput gets each one done in about a week. The numbers are illustrative, but the shape isn’t: more open threads means everything takes longer, including the thing you care about most.
Parallel agents make this easier to forget, because opening another session costs nothing. The agents can run in parallel. Your attention can’t, and your attention is what closes things.
3. Follow-ups go to the session that has the context
Before opening a new chat, check whether a session already holds the background. Here’s the test I use: if your first message would need a paragraph of background, that background already lives in another session. Go there instead.
When you can’t remember where it lives, ask the agent to look before you start:
Before we start: search my open sessions for one that already covers [topic]. If you find one, tell me which and stop, so I can carry on there instead.
This one change would have prevented every duplicate I found. It also means the session that made a decision is the one that sees it through, so the reasoning and the result stay together.
4. Regular clean-up with a definition of done
For code, done is merged. For everything else, done means the output has landed somewhere durable: a record, a ticket, a doc or a sent message. It’s never “it’s in the chat”. A decision that only exists in a chat is a decision nobody will find next month.
Two habits make that stick. The first is a one-line close-out prompt at the end of every session:
We're done here. Log any decisions, actions and the output to the record, tell me what you logged, then archive this session.
Asking it to tell you what it logged is the important bit. You get a quick read of what’s now durable, and you’ll notice straight away if something didn’t land.
The second is a weekly scheduled sweep. Mine only does the reversible, mechanical work: filing sessions into their groups and archiving the ones that are merged and clean. Anything that needs judgement, like a stalled merge request or a draft that was never sent, goes into a short report for me to decide on. It’s the kind of recurring routine that compounds because it runs whether or not I remember. And it keeps a person on the decisions while the machine does the filing. This is the prompt it runs:
Weekly session sweep. Go through every open session and file each one into the group for its workstream. Archive a session only if its PR has merged and its branch is clean, or its output is already in the record. Don't archive anything else, and don't commit, push or send anything. Then give me a short list of the judgement calls: stalled MRs, unsent drafts, sessions duplicating each other, and anything you weren't sure about.
All three prompts are plain text, so they work in Claude Code, Codex or whichever agent you run, as long as it can see your sessions. Where it can’t, paste in the list of open sessions first and act on its answer yourself.
Do you need a session manager?
I looked at the tooling before settling on this, and there’s plenty of it. Claude Code has an agent view, which shows each session as one line and flags the ones waiting on you, but it’s terminal only. Eivind Kjosbakken’s guide to running many Claude Code sessions in parallel covers it well, along with input alerts, recaps and split panes. Claude Squad and amux are session managers for running lots of agents side by side, and amux’s comparison of session managers lists several more, many of them built on tmux. Anthropic’s own agent teams, which let Claude Code instances share a task list and message each other, are still experimental, as Tembo’s orchestration guide notes.
They’re all good at what they do. But what they do is help you run work: start agents, watch them, answer them. None of them tells you that eight of ten sessions are finished, that four chats are doing the same job, or that a merge request has had no reviewer for two months.
You don’t need another tool to keep track of parallel sessions. Groups, a work-in-progress limit and a weekly sweep do that, and you can set all three up this afternoon with what you already have.
This is the same thing I help teams with when they install AI into how they actually work: the model is rarely the bottleneck. How the work flows around it usually is.
Frequently asked questions
How many Claude Code sessions should I run in parallel?
As many as you like can be running, but keep the number you are actively driving small. I pin at most five, and a pin means this week. Little's Law says lead time equals work in progress divided by throughput, so every extra open thread makes every other thread take longer to finish.
Do I need a session manager like Claude Squad or amux?
Not to keep track of your work. Claude Code's agent view, Claude Squad, amux and agent teams help you run many agents at once. Knowing what is in flight, what is done and what is duplicated comes from grouping sessions by workstream, a work-in-progress limit and a regular clean-up with a clear definition of done.
When is a Claude Code session done if it never produced a pull request?
When its output has landed somewhere durable: a record, a ticket, a document or a sent message. A decision or a draft that only exists in the chat is not done, however finished it feels, because nobody will find it there next month.
Join the Drift Digest
One short email in any week I publish, with the highlights from each new post, plus new AI tells as models change and a quarterly nudge to re-measure your voice. No spam, unsubscribe anytime.
Something went wrong. Please try again, or email web@ctoondemand.co.uk.
