OpenRig vs Claude agent teams
Claude agent teams and OpenRig are both ways to run multiple real coding-agent sessions that coordinate with each other. They're closer to peers than any other comparison on this site. The differences are about who operates the system, what runtimes it covers, and how durable the arrangement is — not about whether multi-agent work is possible at all.
Anthropic shipped agent teams as an experimental feature inside Claude Code. You turn it on with a feature flag, and from a lead Claude Code session you can create teammates — additional Claude Code instances with their own context windows — coordinated through a shared task list and direct teammate messaging. OpenRig runs shipped agents (Claude Code, Codex, terminals) as persistent tmux sessions arranged into a rig you define in YAML. Different starting points, overlapping problem space.
Why I publish comparisons. This category is new. The vocabulary isn't settled. Nobody has a complete mental model of what's in the space, including me. The comparisons here are an attempt to find the shape of the category — what approaches are being taken, what each approach looks like, what we might learn from each other. Not a bake-off.
Two different starting points
Claude agent teams started from: what if a Claude Code session could spin up more Claude Code sessions as teammates, with their own contexts and direct messaging, managed from within the same UX? The answer is an in-harness feature. You enable the flag, create teammates with TeamCreate, and Claude Code gives you multi-Claude coordination from inside a single operator surface. The team lives inside Claude Code, scoped to Claude Code, and feels like a natural extension of it.
OpenRig started from a different question: what if you could arrange any mix of shipped coding agents — Claude Code, Codex, terminal processes — into a topology you define outside of any single vendor's product, run it as local infrastructure, and have the whole thing survive reboots? The answer is a topology-first control plane. OpenRig doesn't live inside Claude Code — it manages Claude Code (and Codex, and terminals) from outside, the way Docker Compose manages containers.
Both answers are valid. They optimize for different things. Agent teams optimizes for smooth multi-Claude work inside the Anthropic-blessed UX. OpenRig optimizes for durable, cross-runtime, operator-driven topologies.
Side-by-side
| Axis | OpenRig | Claude agent teams |
|---|---|---|
| What the primitive is | The rig — a topology of running shipped harnesses, defined in YAML. | The team — a lead Claude Code session plus one or more teammate Claude Code instances, created from inside Claude Code. |
| What runs as a node | Claude Code and Codex as they ship. Terminal processes too. | Claude Code teammates. Claude only. |
| Status | Shipped. | Experimental. Gated behind CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1. |
| How you start | rig up demo. A shipped spec gives you 8 agents in one command. | Enable the feature flag, then use TeamCreate (tools-reference) from inside a lead Claude Code session. |
| Where the agents live | Tmux sessions you own, visible in a topology graph and addressable from the OpenRig CLI. | Inside Claude Code's UX. Cycle between teammates in-process with Shift+Down, or each teammate in its own pane via teammateMode: tmux. |
| How agents coordinate | Directly through tmux (rig send / broadcast / chatroom). Rig queue for durable cross-pod signaling, shipping soon. | Team-aware SendMessage plus a shared task list. Teammates can message each other directly. |
| Context model | Each agent has its own context — they're independent Claude Code / Codex sessions. | Each teammate has its own context window (per Anthropic's agent teams docs). Token usage scales with active teammates. |
| Persistence across reboots | rig down snapshots the topology; rig up <name> restores it. Four outcomes reported per node (resumed / rebuilt / fresh / failed). | Not documented as a first-class primitive. The team lives with the Claude Code session that created it. |
| Runtime scope | Cross-runtime: Claude Code + Codex + terminal; Pi and OpenCode adapters in development. | Claude-only by design. |
| Operator posture | Local infrastructure. You operate the rig from the terminal. | Managed from inside Claude Code. You operate the team through the Claude Code UX. |
What each one is best at
Because these are close peers, the more useful question is when each one fits.
Claude agent teams is well suited to: day-to-day multi-Claude work you do entirely inside Claude Code. You're already living in the Claude TUI, you want to spin up a few parallel Claudes for a specific task, message them from a lead session, and tear the team down when you're done. All of that is natural in Claude Code with the feature flag on, and you don't have to leave the product.
OpenRig is well suited to: arrangements you want to keep. You're running a coding setup that mixes Claude Code with Codex and maybe a terminal or two. You want to boot it with one command, save it before you shut down, and bring it back next week with a rig up. You might have arranged your agents organically in tmux and you want to adopt what's already running into a managed topology without rebuilding. You're operating the system as infrastructure rather than working inside a single harness.
Because they live at different layers — one inside Claude Code, one outside all harnesses — they can also coexist. A node in an OpenRig rig is a real Claude Code session; nothing stops that session from using agent teams internally if the feature helps. The layers compose.
What's specific to OpenRig
The overlap is real, so it's worth being clear about where OpenRig does something agent teams doesn't:
- Cross-runtime. Claude Code and Codex in the same rig, coordinating with each other. Agent teams is Claude-only by design.
- Persistence by name.
rig downsnapshots the topology;rig up <name>brings it back. Per-node outcomes reported honestly (resumed, rebuilt, fresh, or failed). Agent teams doesn't document this kind of whole-topology restore. - Adopt what's already running.
rig discoverfinds Claude Code and Codex sessions you launched manually in tmux;rig adoptbinds them into a rig. You don't have to start from scratch. - Services inside a rig. A rig can ship actual software alongside a specialist agent whose job is to run it. The shipped example is HashiCorp Vault with a vault-specialist agent — one command and you have a secrets manager as part of the rig.
- Operator surface outside the harness. A dedicated CLI, a topology graph, a node detail panel, a system log. All the operator work happens in tools designed for it, not inside the harness being coordinated.
None of this is a criticism of agent teams. Agent teams is doing something specific — multi-Claude work inside Claude Code — and doing it well. OpenRig is doing something adjacent: running a cross-runtime topology as local infrastructure. If you need both, you can have both.
Compare other approaches
Quickly build a mental model for multi-agent harnesses and topologies by comparing the leading approaches, including more traditional multi-agent systems.
Claude Managed Agents
The cloud-hosted version of this idea, Claude-only.
Claude Subagents
Delegated specialist workers inside one lead Claude workflow.
CrewAI
Python framework for building agents from LLM API calls.
n8n
Workflow automation with AI nodes, adjacent but a different category.
OpenClaw
Agent-first methodology with a huge community.
Paperclip
Agents running like a company, coordinated through a ticket queue.
Try OpenRig
If you want a persistent, cross-runtime topology you can operate from the terminal, start here.