The first agent is magic. The second one is a scheduling problem. The moment you run two Claude Code sessions, the scarce resource stops being tokens or CPU and becomes something less scalable: your attention. You are now a dispatcher, and the interface you dispatch from is a pile of terminal windows.
This is a practical guide to running several sessions well. Not the maximum number. The number that leaves you reviewing more and scrolling less.
What parallel actually costs
Two sessions running is not twice the work. The agents run in parallel; your review does not. Every session eventually produces a diff, and diffs are reviewed in sequence, by you. Parallelism moves the queue from the machine to you, which is still progress, if you can see the queue.
So the setup that matters is not about running more agents. It is about knowing, at any moment, which session is working, which is waiting on you, and which is done.
The setup that works
Four rules carry most of the weight:
- One worktree per session. Not per agent, per task.
git worktree add ../app-auth -b task/auth-rewrite, then start Claude Code inside it. Sessions stop sharing files, and branch state stops depending on who rangit checkoutlast. - One rule for nothing shared. Decide once: everything a session needs lives in its worktree.
.envin an include file or copied in. Do not let two sessions depend on the same mutable file. - One home for the sessions. A tree or a board that shows every session with its project, branch and status. This can be tabs in one terminal with a naming convention, a multiplexer, or an ADE. What fails is four unrelated windows and your memory as the index.
- One review order. When multiple sessions finish, review in the order they were started, one at a time, adjusting nothing else while you review. Context switching between two diffs is how review quality quietly dies.
How many sessions is too many?
Start with two. Add a third when you notice you are waiting on sessions more often than reviewing them. In practice, people on real codebases settle between two and four concurrent sessions, with one or two more that are effectively parked and will need attention eventually.
The failure mode above that number is not crashes. It is merge disorder: five finished branches, four half-reviewed, none merged, main drifting. The agents did their jobs. The pipeline after them did not exist.
Subagents, agent teams, or separate sessions?
Claude Code itself has two mechanisms for parallel work inside one session: subagents, helper agents a session spawns for focused jobs, and agent teams, several agent instances working one larger task together. They solve a different problem from separate sessions, and the choice is easy once stated:
- Use subagents inside a session when the work is one task with separable corners: research here, a focused edit there. You get one conversation and one result.
- Use agent teams when one feature is big enough to split across agents that must coordinate on the same goal. The orchestration is Claude Code's job, and it shows in one session's log.
- Use separate sessions with worktrees when the tasks are independent: an auth refactor, a docs pass, a dependency bump. These are different outcomes, different branches, and you want them reviewed and merged on their own schedule.
The mistake is treating them as levels of the same thing. Teams scale one task across agents; worktrees scale several tasks across your day. Most productive setups use both on their respective shapes of work.
A session home
Whichever surface holds your sessions, check it against three tests: does it show state (working, waiting, done), does it group sessions by project and worktree, and does it survive a restart?
Leon was built around those three tests. Every session in the tree shows its worktree, its branch and a light; session states can put a session to sleep and wake it later without duplicates; history search covers what each session was asked and answered. The Den draws each live session so the fleet is visible at a glance, and the footer shows usage per agent so you know which limit is about to say no.
None of that is required to run two sessions. Tabs and discipline work. But the discipline has a ceiling around three parallel tasks, and the ceiling arrives without warning. Download Leon if you would rather grow past it on a tree than on memory.