LaunchedEditorial Listing

OpenRig

Esoteric Labs · OpenRig: Open-Source Harness for Running Claude Code and Codex as a Persistent Agent Team

Open OpenRig

OpenRig is a free, open-source (Apache 2.0) multi-agent harness that runs Claude Code, Codex, and Pi sessions as a persistent team defined in YAML. A lead agent delegates to named specialists, work is tracked in an owned task queue, and a terminal UI shows the whole team. It suits developers who already run several coding agents and want them to coordinate on long-running projects on their own machine.

PricingFree
Setupmedium
Runs onSelf-hosted
Open sourceYes
DocsYes
CategoryCoding
Agent OrchestrationMulti-AgentOpen SourceSelf-HostedClaude CodeCodexTerminaltmux

Best for

Developers who already run several Claude Code or Codex sessions on one project and want them organized into a persistent, addressable team they can attach to and steer from the terminal

Not ideal for

Windows users who cannot use WSL2, developers who have not yet outgrown a single agent with subagents, teams that need budgets, approval gates, and a web dashboard, and anyone who does not want a tool writing hooks and trust settings into their Claude Code and Codex configuration

Who it's for

Individual developers and small teams who run multiple Claude Code and Codex sessions and want them to work as a coordinated, long-lived team

Capabilities

  • RigSpec YAML defines a team as pods, seats, edges, and continuity policies, and `rig up` boots the whole topology in tmux with readiness checks
  • Seats are stable addresses such as `dev-build@starter`, so a role keeps its name, guidance, and context when the session occupying it changes
  • Direct agent-to-agent messaging with `rig send`, `rig broadcast`, and `rig chatroom`, plus `rig capture` to read another seat's screen
  • `rig queue` tracks each piece of work with one owner and a state, and handing work to another seat closes one item and opens the next in one step
  • Declared workflows that move work between seats step by step without the user relaying messages
  • Claude Code and Codex in the same rig, plus Pi and Oh My Pi through RPC runners, terminal nodes, and a written contract for community harnesses such as OpenClaw
  • A kernel operator that asks what you want to build, recommends a starter team, adapts it to the providers you have signed in, and launches it in your project
  • `rig down --snapshot` saves a topology and `rig up <name>` restores it, reporting each seat as resumed, rebuilt, started fresh, needing attention, or failed
  • `rig discover` and `rig adopt` bring Claude Code and Codex sessions already running in tmux under management
  • Terminal UI with topology graph and table views, seat details, projects, a feed, and system health, and herdr, cmux, or Rex integration to tile a rig's terminals, including a view that follows the agents working on one task
  • MCP server that lets agents manage their own topology with tools such as `rig_up`, `rig_ps`, and `rig_send`
  • Starter teams `starter`, `workshop`, and the seven-seat `factory`, specialist `code-review`, `research`, and `pm` teams, and a Vault-backed `secrets-manager`, with teams installable from a GitHub folder link
  • Change a running rig with `rig grow`, `rig shrink`, `rig launch`, and `rig remove`, and share topologies as RigBundles with SHA-256 integrity checks
  • Per-seat permission modes with an audited selection, per-seat control over how much automatic input reaches an agent, and an opt-in typing guard for seats you type into by hand
  • Each seat can run on its own Claude or Codex account and move to another login or runtime without leaving its team (v0.7.2)
  • People in the loop: quiet hours and away modes hold routine questions, asks land on the TUI Feed or in Slack, and several people and organization policies can join a team (v0.7.0 to v0.7.3)
  • Early-preview VS Code and Cursor extension (0.1.0) that joins your editor as a seat, hands work to the team, shows what needs you, and reviews results as diffs

Limitations

  • Runs on macOS and Linux. On Windows it supports only WSL2, which its automated tests do not cover yet, and native Windows is not supported. Requires Node.js 22 or 24 (Node 22 on Apple silicon; Node 26 is untested) and tmux
  • Setup, daemon startup, and launches change your machine automatically, without a preview of each write: `rig setup` installs Herdr by default and may install a missing Claude Code or Codex, OpenRig writes workspace trust to `~/.claude.json`, adds hooks and a status-line command to the workspace's `.claude/settings.local.json`, launches Claude seats in `acceptEdits` permission mode, adds hooks and trust entries in `~/.codex/config.toml`, and adds managed guidance to your project's `AGENTS.md` or `CLAUDE.md`. Existing trust entries can be replaced. The README says to back up these files first and that this is not a complete preservation or rollback guarantee
  • OpenRig's own kernel seats get broader default permissions than team seats: full access with no approval prompts on Codex, and file tools, web fetches, and operational commands, including reads under your home folder, without asking on Claude Code. The `workshop` team also ships with broad access and bypasses permission prompts
  • It supplies no model. Every seat uses your Claude Code or Codex login, and the automatically started kernel also runs on one of your authenticated providers, so usage grows with the number of seats you run against those plans
  • Messages are delivered by typing into tmux sessions. OpenRig's docs say delivery and action are separate events and that queued work can still need someone to notice it
  • Self-hosted only, and no managed version is offered. The older web UI is off by default and in maintenance mode, so the CLI and terminal UI are the supported interfaces
  • A young, fast-moving project: pre-1.0, with 21 releases between October 2 and November 8, 2026, daemon restarts and database updates on many upgrades, and agent-run migrations for some older versions. Its creator wrote most of the code, although outside contributors supplied many recent fixes
  • The Slack integration is experimental, and remote MCP access for cloud-hosted assistants (v0.7.4) is experimental, unsupported, and off by default; exposing it means running your own TLS tunnel and issuing tokens that let anyone holding them act within their grant

Use cases

  • Pairing a Claude Code owner with a Codex checker so each change is reviewed by a different model before you see it
  • Running the seven-seat `factory` team of a lead, an advisor, a builder, QA, a designer, and two reviewers on a multi-week feature
  • Keeping long-lived specialist agents for different parts of a codebase and letting them answer each other's questions directly
  • Restoring a whole team of agents by name after a reboot instead of resuming sessions one by one
  • Bringing Claude Code and Codex sessions already running in tmux into one managed, addressable team

Our take

OpenRig takes seriously a problem most multi-agent coding setups leave to the user: once you have more than two or three agents, you become the router between them. Stable seat addresses, direct messaging, an owned task queue, and snapshot and restore let the agents do that bookkeeping themselves, and the shipped starter team sets up cross-model review between Claude Code and Codex out of the box. The costs are also clear. It changes your agent configuration, gives its own kernel broad permissions, depends on tmux and a Unix machine or WSL2, and draws on your plans with every seat, and it is a young, fast-moving project led by one maintainer. Try the two-seat starter on a real repository before committing to a larger rig, and read its list of machine changes first.

Who should use it

Developers and small teams who already juggle several Claude Code or Codex terminals, want cross-model review built into their workflow, and are comfortable with tmux, the command line, and a tool that manages agent configuration for them.

Who should skip it

Windows users who cannot use WSL2, people still getting value from a single agent, teams that need budget limits and approval gates rather than live pairing, and organizations that cannot accept a young, maintainer-led tool changing agent trust and permission settings.

Strengths

  • Free and open source under Apache 2.0, with no API keys or subscriptions of its own
  • Mixes Claude Code and Codex in one team, so different models can check each other's work
  • Every agent is a real tmux session you can attach to and type into
  • Teams survive reboots through snapshots and restore by name
  • Documents in detail what it changes on your machine

Weaknesses

  • macOS and Linux, or Windows through WSL2, with Node.js and tmux requirements
  • Writes hooks, trust settings, and permission modes into your agent configuration, and its kernel runs with broad default permissions
  • Running many seats multiplies usage against your Claude and Codex plans
  • Young, fast-changing project led by one maintainer

OpenRig pricing

Open source

Free

  • Apache 2.0 license
  • CLI, daemon, terminal UI, and MCP server
  • Starter rig library
  • Community support through GitHub Discussions and issues

Note: OpenRig has no paid plan and needs no API keys of its own. Model usage is billed through the Claude Code and Codex subscriptions or logins each seat uses, so running more seats uses more of those plans. Checked against the README and releases through v0.7.10 on 2026-11-09.

Technical specs

Available models

Codex seats: gpt-6-astra in the shipped starter teamClaude Code seats: your configured default Claude model

Where OpenRig excels

Getting every change reviewed by a second model

The `starter` team pairs a Claude Code builder with a Codex reviewer. The builder implements one bounded change, records it in the queue, and asks the reviewer to check the exact candidate before reporting back.

Keeping a large project moving over weeks

Specialist seats keep their roles and context, the queue keeps an owner on every task, and snapshot and restore bring the team back by name after a reboot, so work does not depend on one agent's context window or on you remembering which terminal did what.

Consolidating a sprawl of agent terminals

`rig discover` finds Claude Code and Codex sessions already running in tmux, and `rig adopt` brings them into a managed rig you can see in one terminal UI and address by name.

OpenRig vs. competitors

OpenRig vs. Paperclip

Paperclip organizes agents you already use as a company, with an org chart, tickets, per-agent budgets, heartbeats, and approvals, operated from a web dashboard. OpenRig organizes Claude Code and Codex as persistent tmux sessions that message each other directly and are operated from a CLI and terminal UI. Paperclip suits governed, budgeted autonomy, and OpenRig suits developers who want to pair with a live team of agents.

OpenRig vs. Orca

Orca is a desktop agent development environment for running many CLI coding agents side by side, each in its own git worktree with a terminal, browser, and diff review. OpenRig focuses on how agents work together: named seats, direct messaging, an owned task queue, and a lead agent that delegates. Orca suits parallel independent tasks, and OpenRig suits long-running coordinated work.

Frequently asked questions

What is OpenRig?

OpenRig is an open-source multi-agent harness that runs Claude Code and Codex sessions, and Pi through an adapter, as a persistent team. You define the team in YAML, boot it with `rig up`, and talk mainly to a lead agent that delegates to specialists, tracks work in a queue, and brings back results. It runs locally as a daemon, CLI, terminal UI, and MCP server on top of tmux.

Is OpenRig free?

Yes. OpenRig is Apache 2.0 licensed and self-hosted, and no paid plan is listed. It uses your existing Claude Code and Codex logins, so you still pay for model usage through those accounts. In the shipped `starter` team the Codex reviewer uses gpt-6-astra, and Claude seats use your configured default model.

Which coding agents does OpenRig support?

Claude Code and Codex run natively, and a rig can mix both. Pi and Oh My Pi run through RPC runners, generic terminal nodes can run other processes, and community harnesses such as OpenClaw follow a written contract. You only need the provider you plan to use; the others do not have to be installed.

Does OpenRig work on Windows?

Only through WSL2. OpenRig supports macOS and Linux, and WSL2 is its supported route on Windows, although its automated tests do not run on WSL2 yet and the docs point to one user's working setup. Native Windows is not supported. It needs Node.js 22 or 24 (Node 22 on Apple silicon) and tmux.

How is OpenRig different from Claude Code subagents or agent teams?

Subagents and agent teams are Claude Code features, run from a Claude Code session and limited to Claude. OpenRig runs separate, named Claude Code and Codex sessions that message each other directly, stay alive in tmux while the machine is on, and can be restored by name after a reboot. OpenRig's docs say to keep using subagents, since each seat can still use its own.

What does OpenRig change on my machine?

Besides its own state in `~/.openrig`, `rig setup` writes an OpenRig block to `~/.tmux.conf`, installs Herdr unless you pass `--no-herdr`, and may install a missing Claude Code or Codex. The daemon seeds discovery skills in `~/.claude/skills` and `~/.agents/skills` and, by default, adds hooks and trust entries to `~/.codex/config.toml` once a Codex seat exists. Managed Claude launches write workspace trust and onboarding completion to `~/.claude.json`, add a status-line command and activity hooks to the workspace's `.claude/settings.local.json`, and run with the `acceptEdits` permission mode, while Codex seats get a trusted-workspace entry. Starting a team adds managed guidance to `AGENTS.md` or `CLAUDE.md` plus the team's skills and plugins. OpenRig's own kernel gets broader permissions than project teams, while YOLO mode is off by default for teams. The README lists these changes in detail and recommends backing up the files before first use.

OpenRig vs Paperclip: what is the difference?

Paperclip runs agents as a company, with an org chart, tickets, budgets, heartbeats, approvals, and a web dashboard. OpenRig runs agents as a topology of always-on tmux sessions that message each other directly, and you attach to any of them from the terminal. Paperclip leans toward governance and cost control, and OpenRig toward working live alongside the agents.

Integrations & fit

Claude CodeOpenAI CodexPiOh My PitmuxherdrcmuxRexMCPVS Code (preview)Cursor (preview)DockerHashiCorp VaultSlack (experimental)
Good fit forSolo / individual, Startup / small team
Pricing modelFree· No cost to start
See pricing on OpenRig →

Alternatives to consider

About OpenRig

OpenRig does not replace Claude Code or Codex. It launches and coordinates them. You describe a team in a RigSpec YAML file as pods of seats, where each seat is a stable role and address such as `dev-build@starter`, and `rig up` starts every seat as an ordinary Claude Code or Codex session in tmux. Sessions can end and be replaced while the seat keeps its name, guidance, and context. Agents talk to each other directly: `rig send` types a message into another seat's session, `rig capture` reads its screen, and `rig queue` records work with a single owner so handoffs do not get lost between terminals. Declared workflows can move work from one seat to the next without you relaying messages. After installation, a kernel operator asks what you want to build and recommends one of three teams: `starter`, a Claude Code builder with a Codex reviewer for one bounded change (adapted to one provider if that is all you have), `workshop`, a lead, builder, QA, and reviewer for ongoing work in one repository, or `factory`, seven seats with a lead, an advisor, build, QA, design, and two reviewers. `rig down --snapshot` saves the topology and `rig up <name>` restores it after a reboot, reporting which seats resumed, were rebuilt, or started fresh. Existing tmux sessions can be discovered and adopted, and an MCP server lets agents inspect and change their own topology. Everything runs locally as a daemon with a SQLite database, a CLI, and a TUI. OpenRig needs no API keys of its own and uses the Claude Code and Codex logins you already have, so the cost is your model usage. Since October 2026, seats can also run on their own Claude or Codex accounts, people can set quiet hours so routine questions wait, and an early-preview VS Code and Cursor extension lets your editor join the team as a seat. The tradeoffs are setup and trust. It runs on macOS and Linux, or on Windows through WSL2, with Node.js 22 or 24 and tmux. Starting OpenRig writes hooks and workspace trust settings into your Claude Code and Codex configuration, which the README recommends backing up first, and its own kernel seats run with broad default permissions. The project is young and moves fast, with 21 releases between October 2 and November 8, 2026. Its creator wrote most of the code, while outside contributors now supply many of the fixes.

Updates from OpenRig

New FeatureOpenRig extension for VS Code and Cursor enters early preview

Version 0.1.0 of the OpenRig extension, published on November 7, 2026, lets you work with a local OpenRig team from VS Code or Cursor: join as the editor's seat, hand work to the team, see what needs you, open an agent's terminal, review results as diffs, and give the editor's agent the team's tools.

New FeatureOpenRig 0.7.4 lets cloud-hosted assistants join a team experimentally

A cloud-hosted assistant can join a rig as a hosted member through `rig mcp serve --http`, taking work from its own inbox until its grant is revoked. OpenRig calls this experimental and unsupported. It is off by default and needs your own TLS tunnel or proxy and a narrowly scoped token. The release also lets you resume the exact Claude Code or Codex conversation you choose.

New FeatureOpenRig 0.7.2 gives each seat its own account

A seat can run on its own Claude or Codex account and move to another login or to the other runtime without leaving its team. v0.7.0 and v0.7.1 had already added quiet hours and away modes, per-seat control over automatic input, and asks on the TUI Feed or in Slack, and v0.7.3 added several people, Slack shared channels, and organization policies.

New FeatureOpenRig 0.6.2 adds first-project provider choices

The first-use path now offers the same owner and checker team as two Codex agents (`first-project`), two Claude Code agents (`first-project-claude`), or a Claude owner with a Codex checker (`first-project-mixed`), so a second provider login is not required. The release also clarified permission guidance and fixed bundle installation and agent message delivery. v0.6.3 followed the same day with a fix for messaging managed Claude seats.

New FeatureOpenRig 0.6.0 adds per-seat permissions and requires Node 22 or 24

v0.6.0 added per-seat permission choices for future launches, an opt-in typing guard for seats you type into by hand, a single TUI action to open a whole rig in Herdr, and experimental Slack app manifest support. It dropped Node.js 20 support.

Are you the founder? Claim this listing →