Introduction
Claude Code Agent Teams (experimental, launched early 2026 behind the CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS flag) lets one Claude Code session act as a team lead that coordinates other Claude Code sessions working on subtasks. Teammates run in their own context windows and message each other directly. With tmux or iTerm2, each teammate gets its own split pane.
It is a genuinely interesting pattern - but it only solves one half of the multi-agent problem. Agent Teams assumes you are sitting at the terminal during the whole run. It does not schedule jobs, does not run unattended, has no mobile monitoring, and is single-provider (Anthropic only). ClawTab handles exactly those scenarios: flat tmux swarms with per-agent schedules, secrets, auto-yes, and phone control - across Claude Code, Codex, and OpenCode.
The two are complementary. This article explains where Agent Teams fits, where it does not, how ClawTab covers the gap, and how it compares to the other multi-agent orchestrators that have appeared in 2026 - Claude Flow (now Ruflo), Crystal (now Nimbalyst), ccswarm, Overstory, oh-my-claudecode, and Shire.
What Claude Code Agent Teams Actually Is
Agent Teams is a coordination primitive built into Claude Code. When enabled, one session becomes the team lead: it assigns tasks, watches progress, synthesizes results, and decides when the work is done. The other sessions are teammates: each runs in its own context window, receives messages from the lead (and from peers), and reports back.
The key technical details matter for deciding when to use it:
- Opt-in, experimental. Requires
CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1in your environment orsettings.json. Expect changes. - Three display modes. In-process runs all teammates inside the main terminal (Shift+Down cycles between them). Split panes gives each teammate its own tmux or iTerm2 pane. Auto picks split panes if already inside tmux, otherwise in-process.
- Control mode. With
tmux -CC, iTerm2 maps panes to native tabs. Cleaner than hotkey cycling. - Peer-to-peer messaging. Unlike sub-agents (which report back only to the parent), teammates talk to each other. The team lead synthesizes, but the conversation graph is not strictly hierarchical.
- Token cost scales linearly. Every teammate is a full Claude Code session with its own context window. Running 6 teammates costs ~6x a single session.
- Known limitations. Session resumption, task coordination, and shutdown behavior are all rough edges. Stray tmux sessions may persist after the team exits.
Done well, Agent Teams is great for large interactive features where you want parallel tracks of work, a QA swarm that tests from multiple angles, or a "competing hypotheses" setup where two teammates argue two approaches and converge. It is a collaborative tool, not a fire-and-forget runner.
What Agent Teams Does Not Cover
Agent Teams is built around a live, interactive team-lead session. Once you step away from that session, the model breaks down. The scenarios it does not handle:
- Scheduled jobs. Agent Teams has no cron integration. You cannot say "run this 6-agent QA swarm every night at 2am." The team lead has to be started interactively.
- Long unattended runs. Every teammate still hits permission prompts. Without a separate auto-approval mechanism, the whole team stalls waiting for your keystrokes.
- Multi-provider swarms. Agent Teams is Claude Code-only. It cannot coordinate Claude Code plus Codex plus OpenCode in one swarm.
- Mobile monitoring. There is no phone UI. If you leave your desk, you lose visibility into what the team is doing.
- Per-agent secrets and working directories. Each teammate inherits the lead's environment. There is no built-in way to give teammate A production read-only credentials and teammate B a staging sandbox.
- Independent lifecycles. The team is one cohesive unit. You cannot trivially say "kill teammate 3, restart teammate 5, leave the other four running."
- Hosted relay for remote control. No ability for a phone or laptop to answer a prompt in a running teammate from across the network.
These are not bugs - they are outside the scope of what Agent Teams is trying to do. Agent Teams is about coordination during an interactive session. Unattended orchestration is a different problem.
ClawTab's Flat Tmux Model
ClawTab approaches multi-agent differently. Instead of a team-lead hierarchy inside one Claude Code session, it runs every agent as an independent tmux process with its own schedule, secrets, permission policy, and remote control surface. There is no lead. Agents can still coordinate by reading shared files or git commits, but the orchestration layer is the user (or cron), not another LLM.
Concretely, in ClawTab:
- Per-agent tmux window. Each job runs in its own window, with persistent output capture and logging. Windows survive reboot via session persistence.
- Cron scheduling. Standard cron expressions, 30-second poll interval, survives reboots. Schedule Claude Code agents at 2am without being at your desk.
- Per-pane auto-yes. Each agent has its own permission policy. Agent A auto-accepts, agent B still prompts you. Set it from your phone without going back to the desktop.
- Secrets injection. Each job gets its own env vars from macOS Keychain or gopass. No credentials in the repo, no shared environment.
- Multi-provider. Claude Code, Codex, and OpenCode run side by side in the same swarm. Compare approaches on the same prompt.
- Phone control. remote.clawtab.cc and the iOS app stream live output for every pane, detect pending prompts, render buttons, and send answers back. Push notifications via APNs and Telegram.
- Workspace sharing. Hand off a live swarm to a teammate - they answer prompts, toggle auto-yes, and monitor from their own phone.
The philosophy: agents should run like any other background process on your machine. Cron, logs, secrets, remote access. No special LLM-to-LLM protocol required. If you need agents to collaborate, use git commits or shared files - the same primitives you already trust.
Side-by-Side: Agent Teams vs ClawTab
The two tools overlap on the surface (both run multiple agents) but almost never compete in practice. Here is the dimension-by-dimension comparison:
| Capability | Claude Code Agent Teams | ClawTab |
|---|---|---|
| Coordination model | Team lead + peer messaging (LLM-to-LLM) | Independent flat tmux processes (user or cron orchestrates) |
| Providers | Claude Code only | Claude Code, Codex, OpenCode |
| Scheduling | No (interactive only) | Yes (cron, 30s poll, survives reboot) |
| Unattended runs | No (prompts stall) | Yes (per-pane auto-yes) |
| Permission granularity | Session-wide | Per pane |
| Secrets per agent | Shared env | Per-job Keychain / gopass injection |
| Mobile monitoring | No | Yes (iOS app, web, Telegram) |
| Answer prompts remotely | No | Yes (relay-backed) |
| Partial restart | Team is one unit | Start/stop/restart any pane independently |
| Best for | Interactive, collaborative, multi-angle work | Scheduled, unattended, multi-provider, remote |
| Stability | Experimental | Stable (v0.3) |
| Cost | Linear per teammate (full Claude sessions) | Same underlying cost, but you control concurrency |
The takeaway: Agent Teams is collaboration during a session. ClawTab is orchestration across sessions and time. Different jobs.
How the Other Alternatives Compare
Claude Code is popular enough that an ecosystem of third-party multi-agent tools has appeared. Several were renamed in 2025-2026 as the space matured: Claude Flow became Ruflo, Crystal became Nimbalyst. Here is what each one actually does, with screenshots where the tool has a visual UI:
Nimbalyst (formerly Crystal)
Crystal was rebranded to Nimbalyst in 2026 as it expanded beyond multi-session management into a broader "agent-native visual workspace." The GitHub repo still hosts the code under stravu/crystal. It is a desktop app that spins up a Claude Code (and now Codex) instance inside each git worktree, so you can run several parallel sessions on the same repo without branches colliding.
Nimbalyst is the easiest entry point to parallel Claude Code sessions - the UI is clicky and intuitive, and the worktree-per-session model makes it safe to experiment. It does not ship scheduling, mobile monitoring, or per-agent auto-yes, so once you want unattended runs or remote control, ClawTab is the natural next step. The two do not conflict - you can run Nimbalyst for interactive comparison work and ClawTab for scheduled background jobs.
Ruflo / Claude Flow
Ruflo (originally Claude Flow, rebranded in 2026) is the heavy-weight end of the spectrum. It is a CLI orchestration platform with a "hive-mind" coordination model - a Queen agent assigns work to specialized Worker agents, all backed by a SQLite shared-memory store so agents can learn across sessions. Claimed metrics: 84.8% SWE-bench solve rate and ~75% API cost savings vs raw Claude Code.
Ruflo has no desktop UI - it is configured via config files and run from the command line. The learning curve is the steepest in this list, but if you want a persistent, long-running, LLM-driven orchestrator for multi-day workflows, it is the closest thing to an agent OS. ClawTab does not try to compete on the coordination-inside-agents axis; it handles the operational layer (scheduling, secrets, phone control) that Ruflo leaves to you.
Overstory
Overstory is a pluggable multi-agent runtime with 11 adapters - Claude Code, Pi, Gemini CLI, Aider, Goose, Amp, and others. Workers spawn in git worktrees via tmux. Coordination happens through a custom SQLite mailbox (WAL mode, ~1-5ms per query) with typed protocol messages. A FIFO merge queue with 4-tier conflict resolution merges branches back to canonical, and a three-tier watchdog (mechanical daemon, AI-assisted triage, monitor agent) keeps the fleet healthy.
No visual UI - Overstory is CLI-only. It is the right fit if you want opinionated worktree-per-agent isolation with sophisticated inter-agent messaging and are comfortable running a daemon. ClawTab is a better match when you need a desktop UI, scheduling, and phone control over a simpler flat-tmux model.
ccswarm / oh-my-claudecode
oh-my-claudecode and ccswarm are tmux-based swarm runners with git worktree isolation. Similar concurrency model to ClawTab's tmux pane approach, but CLI-only with no mobile UI, no cron integration, and no multi-provider support. Good for developers who live in tmux and want a lightweight swarm without a GUI.
Shire
Shire provides persistent workspaces with inter-agent mailboxes and a shared drive. Multi-provider (Claude Code, OpenCode, Pi). Aimed at long-running team workflows with full context preservation across weeks, not single sessions. Closer in spirit to Ruflo than to ClawTab.
Multi-agent Shogun / claude-swarm-orchestration
claude-swarm-orchestration is a hierarchical samurai-themed tmux runner. Up to 10 parallel agents with zero coordination API cost. Purely local, no remote, no scheduling.
The pattern that emerges: every tool makes a different trade between LLM-driven coordination, local tmux simplicity, and operational concerns (scheduling, secrets, remote). ClawTab deliberately skips the LLM-driven coordination layer and doubles down on the operational side - schedule, monitor, answer from phone, inject secrets, share with teammates. If you want the Queen-Worker architecture, Ruflo or Overstory is the right fit. If you want clicky visual parallel sessions, Nimbalyst is. If you want unattended scheduled runs with mobile control, ClawTab is.
Setup: Agent Teams and a ClawTab Swarm Side by Side
The two tools cooperate well. A realistic setup: during the day you run an Agent Teams session for a collaborative feature build. At night a ClawTab cron swarm runs unattended maintenance jobs. Here is how to wire it up.
1. Enable Agent Teams in Claude Code.
export CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1
# or add to ~/.config/claude/settings.json
# "experimental": { "agentTeams": true }
2. Install ClawTab.
brew install --cask tonisives/tap/clawtab3. Run Agent Teams interactively (split-pane mode). Start Claude Code inside a tmux session - ClawTab uses tmux anyway, so its windows are already there. Ask the team lead to spawn 3 teammates. Each teammate gets its own tmux pane. You work with the team in the foreground.
4. Register a ClawTab cron job for unattended work. In the ClawTab desktop app, add a scheduled job: command claude, cron expression 0 2 * * *, working directory your repo, auto-yes enabled, secrets injected from Keychain. This job runs every night regardless of whether Agent Teams is running.
5. Share the workspace with your phone. Pair your iOS device via remote.clawtab.cc. Now you can watch any pane (Agent Teams teammates or ClawTab cron jobs) from the phone and answer prompts remotely.
6. Separate the concerns. Keep collaborative, interactive, multi-angle work inside Agent Teams. Keep scheduled, unattended, multi-provider, or long-running work inside ClawTab. Do not try to force one model into the other's job.
When to Pick Which
Short version:
- Pick Agent Teams when you are at the keyboard, the work needs LLM-to-LLM coordination (large feature, QA swarm, competing hypotheses), all agents are Claude Code, and the session ends when you stop watching.
- Pick ClawTab when the work has to run on a schedule or overnight, you want multiple providers in the same swarm, you need to answer agent prompts from your phone, each agent needs its own secrets or permission policy, or you need to restart individual agents without tearing down the swarm.
- Pick both when your day covers both modes - interactive feature work and background automation. They do not conflict; they operate on different tmux windows.
- Pick Ruflo (Claude Flow) or Overstory when you want a heavy LLM-driven orchestrator with shared memory and long-horizon context, and you are willing to operate it.
- Pick Nimbalyst (Crystal) if you just want to try parallel Claude Code sessions visually with zero config. When you outgrow it, move to ClawTab.
The multi-agent landscape is genuinely healthy in 2026 - different tools for different shapes of problem. Agent Teams is a great primitive for one of those shapes. ClawTab's flat-tmux model is a great primitive for the other.
