I didn’t start out trying to run “a lot” of sessions.

It just happened naturally:

• one Claude Code session refactoring a module
• one Codex session doing some repetitive cleanup
• an OpenCode session exploring an alternative approach

…and then you blink and you have ten.

At that point the hard part isn’t starting sessions.

It’s the attention problem:

Which sessions need me right now, and which ones are still doing fine?

If you don’t solve that, parallel sessions don’t feel like leverage — they feel like a slow panic.

This is the workflow I use to make parallel sessions boring.

TL;DR

1. Decide your isolation strategy:
   • one repo copy (fastest, most conflict-prone), or
   • git worktrees per session (cleanest parallelism)
2. Adopt a naming rule (repo + goal) so your “session list” is readable.
3. Pick one “attention list” surface:
   • a TUI dashboard (tmux manager), or
   • a phone/browser UI with Inbox/notifications.
4. If you want phone-first attention routing, Happier is one option that helps because Inbox/approvals are durable and notifications deep-link to the right session (and right server profile).

The problem (in plain language)

When you run multiple sessions, three things start breaking:

1. Isolation: sessions stomp each other’s files.
2. Context: you forget what each session was doing.
3. Attention: you miss the one session that’s blocked on approval while you stare at another that’s happily chugging.

People often try to solve (3) with “more terminals.” That’s not actually an attention system.

What I tried first (and where I bounced off)

• Just open more terminals/tmux panes: works until it doesn’t; the scan cost scales linearly.
• One tmux session per repo with careful naming: better, still manual.
• Community TUIs (cmux / claude-squad / agent-deck): great if you live in a terminal and want a dashboard.
• Claude Code Remote Control + Agent Teams: helps if you adopt Claude’s ecosystem, but it’s still provider-specific.

Happier is one of the options I use when I want a cross-provider attention list and a phone UI for approvals/diffs.

If you’re new to Happier (what it is, and where to get it)

If you haven’t seen Happier before: it’s an open-source companion app (mobile/web/desktop) for sessions like Claude Code, Codex, and OpenCode.

The workflow is: sessions run on a computer you trust (or multiple computers), and Happier is where you monitor, approve, and keep work moving from your phone.

Get set up:

• How to run Happier from your phone
• GitHub: https://github.com/happier-dev/happier
• Install/download: https://github.com/happier-dev/happier#how-it-works
• Discord: https://discord.gg/W6Pb8KuHfg

Step 1: pick an isolation strategy (this matters more than “session count”)

Option A: shared working directory

This is the default if you just start multiple sessions in the same repo checkout.

It’s fast.

It’s also how you end up with:

• conflicting edits
• half-applied changes
• “which session created this file?” confusion

If you do this, you need strict discipline: one session does read-only/review; one session does write actions.

Option B: git worktrees per session (recommended)

Worktrees are the simplest way I’ve found to make parallel sessions predictable.

Each session gets:

• its own working tree
• its own branch

That means:

• fewer conflicts
• easier cleanup
• easier “this session owns this change” mental model

The trade-off is overhead: you have to create and delete worktrees and keep branches tidy.

Step 2: name sessions like you’ll forget them (because you will)

My naming rule is simple:

• repo name
• goal
• optional constraint

Examples:

• api: refactor auth middleware (keep behavior)
• web: upgrade deps (no UI changes)
• cli: fix install script (mac+linux)

This is boring, but it’s what makes any dashboard useful.

Step 3: solve “attention” explicitly (not with more panes)

You need one place that answers:

• what’s running
• what’s waiting for approval
• what’s done

Terminal-first options:

• a TUI manager that shows active sessions and lets you jump quickly

Phone-first options:

• an Inbox/notification workflow that brings you to the exact session that needs input

The Happier workflow (Inbox + pending queue + safe notification routing)

The thing I like about Happier for parallel sessions is that it’s opinionated about attention:

• Inbox is the place for “things that need your attention” (approvals, requests)
• notifications are session-aware and multi-server-aware
• pending queue lets you queue follow-ups without guessing whether the session is ready

That combination turns “I have 12 sessions” into “I have 2 things to answer.”

Practical operating rules (that keep me sane)

• If a session needs a big risky decision, fork it instead of continuing in-place.
• If I’m on my phone, I only do:
  • approvals
  • small steering messages
  • diff review
• Everything else waits for a keyboard.

Related guides

• How to tell which Claude Code/Codex/OpenCode session is stuck
• Stop “waiting for approval”
• How to queue messages from your phone while an agent is busy