How to run multiple Claude Code sessions at once on a Mac

Every claude process you start is one session: a conversation tied to the directory you launched it from, saved continuously to a transcript on disk. Two sessions in the same folder are allowed. They share the files, not the conversation. That distinction drives everything else in this guide: parallelism is easy, collisions on the working tree are the part you have to design for.

Four commands matter when you run more than one session:

The zero-setup baseline. Open a tab per agent in Terminal, iTerm2, Ghostty or whichever app you use, cd into the repo and start each session with a name:

cd ~/code/shop
claude -n checkout-refactor      # tab 1
claude -n flaky-tests            # tab 2
claude -n docs-pass              # tab 3

What you get: nothing to install, the real CLI, your own login.

Where it breaks:

• You cannot see which agent is waiting for an answer without visiting each tab. With three agents you check; with six you forget one for an hour.
• Quitting the terminal app ends every session. The transcripts survive on disk, but you resume each one by hand with claude --resume <name> the next morning.
• All tabs share one working tree. Two agents editing the same package step on each other's changes, and a test run in one tab sees half-finished edits from another.

Fine for two sessions once in a while. Past three, daily, the tabs start costing you attention.

tmux keeps terminals alive on a server process, so your sessions outlive the terminal window. One tmux session with a pane per agent is the classic setup:

tmux new -s agents
# Ctrl-b %  splits vertically, Ctrl-b "  horizontally; run claude in each pane
claude -n checkout-refactor
# Ctrl-b d  detaches; the agents keep running
tmux attach -t agents

What you get: detach and reattach, keyboard-driven layouts, works over SSH on any Unix box. Claude Code's full-screen interface runs inside a pane like in any terminal.

Where it breaks:

• A reboot or a crashed tmux server ends everything at once. You are back to resuming each session by name.
• Panes divide one screen. Four agents are readable; eight are postage stamps, and you end up cycling windows, which is tabs again.
• tmux has no idea what a pane is doing. Nothing tells you that the agent in pane 3 has been waiting for permission for twenty minutes.
• Same shared working tree as tabs, unless you combine it with worktrees below.

tmux is the right answer for remote servers and for people who live in the keyboard. The full comparison with Hypervibe goes row by row.

Tabs and tmux solve where the terminals live. Worktrees solve the collision problem: each session gets its own working directory and branch, sharing the repository history with your main checkout. One session builds a feature while another fixes a bug, and neither sees the other's half-written files.

Claude Code has this built in:

claude --worktree feature-auth
# creates .claude/worktrees/feature-auth on branch worktree-feature-auth
claude -w bugfix-cart            # -w is the short form; run it in another terminal

Add .claude/worktrees/ to your .gitignore. If your project needs an .env or other ignored files in every worktree, list them in a .worktreeinclude file at the repo root and Claude Code copies them into each new worktree. When you exit, Claude checks the worktree for uncommitted work and asks whether to keep or remove it.

You can also manage worktrees with git directly, which is what you will do for CLIs that lack the flag:

git worktree add ../shop-feature-a -b feature-a
cd ../shop-feature-a
claude -n feature-a

What you get: isolation. Tests in one worktree run against that worktree only. Resume works too: a resumed session returns to its worktree, and the session picker widens to all worktrees with Ctrl+W.

Where it breaks:

• Each worktree is a full checkout. Dependencies (node_modules, virtualenvs, build caches) are installed per worktree, which costs disk and setup time.
• Worktrees fix files, not attention. You still need somewhere to put the N terminals, so worktrees compose with tabs, tmux or a board rather than replacing them.
• Merging is on you. Parallel branches converge through normal git, with normal conflicts.

This is what Hypervibe does, so read this section as the maker's view. Each console on the board is the real claude binary from your PATH, started in a real pseudo-terminal, signed in with your own account. No API key and no wrapper: Ctrl-C, the permission prompts, /resume, everything behaves as in your terminal, because it is your terminal. The board is what sits around it.

• Status without visiting. The mission map shows every console as working, resting or needing you. The signal comes from Claude Code's own hooks, not from guessing at the screen.
• Everything comes back. Quit the app with five consoles open. Reopen it and each console relaunches in place and offers to resume its last conversation through Claude Code's native resume. Workspaces are saved to disk on every change.
• Room for more than four. A visual board with pan and zoom, and workspaces you switch like tabs, instead of a fixed grid of panes.
• Handoffs between agents. "Pass this to codex" summarizes the outgoing session and lands the brief on the next agent as a prepared prompt. You press Enter.
• Loops, voice, notes. Trigger a console on a schedule, on idle or on output; direct the board by voice; keep a kanban and notes next to the consoles.
• Usage in view. A usage pill per CLI and token analytics per day and agent, read from the local session logs. Useful precisely because parallel sessions drain a plan faster.

Where it does not help: it runs on macOS 14 or later on Apple Silicon only. It does not raise your plan limits. And isolation is still your decision: open one console per worktree when agents write to the same repo.

If you run two sessions once a week, tabs are the right tool. The board starts paying for itself at three or more agents, every day.

1. Name every session at start (claude -n). Names are what you resume by, and the session picker shows them alongside the branch and time since last activity.
2. One writing task per working tree. Read-only sessions (review, explain, plan) can share a checkout. Anything that edits gets a worktree.
3. Split inside a session before spawning another. Claude Code's subagents parallelize work within one conversation and can run in their own worktrees. Reach for a second session when the work is genuinely a second task, or when you want a different agent's opinion.
4. Let hooks tell you when an agent is waiting. Claude Code hooks run a command on events such as a notification or the end of a turn. That is how Hypervibe drives its status pills; without a board, a hook that posts a desktop notification is the next best thing.
5. Watch session size. Long conversations cost more per request. On Pro and Max, resuming a session over 100,000 tokens after an hour of inactivity offers to resume from a summary instead. Splitting work into sessions keeps each one smaller.