Running one Claude Code session is simple: open a terminal, start claude, and work. The
questions start when you want several at once, a refactor here, a test suite there, a doc pass
in a third repo. Each session runs fine on its own; the hard part is keeping track of all of
them and stepping in when one stops to ask you something. This page compares the common ways to
do that on macOS, and says plainly where each one wins.
What are the options?
Most people reach for one of five approaches: plain terminal tabs, a terminal multiplexer like tmux, git worktrees, an editor such as VS Code, and a dedicated session manager (Helmsman is one). They are not mutually exclusive. Worktrees, in particular, pair with any of the others. The table below is a quick map; the sections after it go deeper.
| Option | Setup | See at once | Isolation | Steering |
|---|---|---|---|---|
| Terminal tabs | None | One at a time | Shared checkout | Type in the front tab |
| tmux | Some config | A tiled pane grid | Shared checkout | Type in the active pane |
| git worktrees | One command per tree | Depends on your terminal | Separate checkout per tree | In the tree’s own terminal |
| VS Code | Install, plus an extension | One per window | Depends on setup | In the editor, with diffs |
| Dedicated app (Helmsman) | Install, invite-only beta | Twelve per deck, fifty in all | Shared checkout (pairs with worktrees) | Type into any cell |
When are plain terminal tabs enough?
Plain terminal tabs are enough when you run two or three sessions and mostly work in one at a
time. They cost nothing to set up: open a tab, start claude, switch with a keystroke. The
tradeoff is visibility. A tab shows only the front session, so a background session can finish,
or stop to ask for approval, without you seeing it. If you rarely run more than a couple of
sessions and tend to babysit each in turn, tabs are the right amount of tool and nothing more.
When is tmux the right tool?
tmux is the right tool when you live in the terminal, especially over SSH. It is free, scriptable, and tiles several panes on one screen, so you can watch multiple sessions at once. Its real advantage is persistence: a tmux session keeps running when your SSH connection drops or you close the laptop, and you reattach later to find the work where you left it. If you already have tmux muscle memory, or you drive a remote box, it is hard to beat. The cost is the learning curve and the config, and a wall of small panes takes discipline to scan, because nothing surfaces which one is waiting on you.
What do git worktrees solve, and what do they not?
Git worktrees solve file conflicts between parallel sessions, and little else. A worktree is a
second working copy of the same repository on its own branch, so two sessions can edit the same
project without stepping on each other’s files. This is Anthropic’s own documented approach to
parallel work: the claude --worktree <name> flag is built into the CLI, and the Claude Code
Desktop app auto-creates a worktree per session for git repositories. See Anthropic’s
worktrees guide and
common workflows.
What worktrees do not isolate is everything outside the file tree. They share the same databases, the same ports, and the same running services. Two sessions that each start a dev server on port 3000, or both write to one local database, will collide even in separate worktrees. Worktrees are a file boundary, not a runtime boundary; you still need separate ports, database names, or containers if your sessions run live services.
What does VS Code give you?
VS Code gives you Claude Code next to your editor and your diffs. The Claude Code extension runs a session inside the editor, so you review an agent’s changes in the same window where you read and stage code. Running several sessions usually means several editor windows, so the visibility question returns at scale, but if the editor is your home base rather than the terminal, that integration is the draw.
When does a dedicated app like Helmsman earn its place?
A dedicated session manager earns its place when you run enough sessions that seeing all of them
at once, and steering the one that needs you, becomes the whole job. Helmsman is one such app:
it spawns your own local claude CLI into a grid of up to twelve live terminals per deck, fifty
sessions in all, so
every session stays on screen and you can watch which are working and which are waiting, then
type into any cell to steer it. That closes the gap tabs and panes leave open: a session
that stops for approval does not sit unnoticed. Helmsman is in an invite-only beta, and it runs
your existing claude locally rather than replacing it. For comparison, as of July 2026 Claude
Code’s own Desktop app shows up to two sessions side by side, and its Agent Teams split panes
rely on tmux or iTerm2 (see Anthropic’s Desktop and
Agent Teams docs).
It is not the right tool for every case. If you run a single session, tabs are simpler. If you work mostly over SSH or on a remote box, tmux’s persistence matters more than an on-screen grid. And if you already think in tmux, its muscle memory will beat any new window. A dedicated app is for the case where local visibility across many sessions is the bottleneck.
How many sessions can one person actually supervise?
There is no settled number, and anyone who gives you one is guessing. Estimates from people who do this range from two or three sessions to ten or more, and they depend on the person, the tasks, and how much each session runs on its own before it needs a decision. The honest ceiling is not the tool; it is you. Every session that stops to ask a question waits on your review, and approval prompts can sit idle for twenty minutes or more if you cannot see them. Whatever setup you pick, the real limit is how many streams of work you can read and steer without one going quiet unnoticed.
Whichever tool fits, the working rhythm is the same: keep the sessions in view, act on the one that needs you, and step back. To see how Helmsman handles the first half of that, read about the session grid. For the second half, focus and steer walks through the loop of scanning, focusing a cell, and stepping back.