OpenRig Setup: Run Claude Code and Codex as One Team

OpenRig is a free, Apache-2.0 command-line tool that turns Claude Code and Codex from a pile of separate terminal sessions into a persistent, named team: you describe the team in YAML, boot it with rig up, and talk to a lead agent that hands work to the others. It picked up 640 GitHub stars today and has about 3,600 in total, and on a Mac or Linux box with Node.js and tmux you can have a two-agent owner-and-checker pair working in your own repository in about fifteen minutes.

• It is a harness for harnesses: OpenRig does not wrap a model or build its own agent. It launches the Claude Code and Codex CLIs you already use, unchanged, each in its own tmux session.
• Requirements are short but strict: Node.js 22 or 24, tmux, macOS or Linux. Native Windows is not supported, and WSL2 has not been tested.
• You need a working Claude Code or Codex login, not a new subscription. The three starter teams cover two Codex agents, two Claude agents, or one of each.
• Current release is v0.6.3 (30 September 2026), installed from npm as @openrig/cli. It writes hooks and trust settings into your agent configs, so back them up first.

The exact steps, start to finish

1. Check your prerequisites. Run these in a macOS or Linux terminal. You want Node 22 or 24, any tmux, and the CLI for the provider you plan to use (one is enough).

   node --version
   tmux -V
   # Claude Code users
   claude --version
   # Codex users
   codex --version

2. Back up the files OpenRig will touch. Copy ~/.claude.json, ~/.codex/config.toml and ~/.tmux.conf somewhere safe. The project's own README asks you to do this before the first launch.
3. Install the CLI and preview setup. The dry run shows what rig setup would change without applying anything.

   npm install -g @openrig/cli
   rig setup --dry-run

4. Sign in to the provider you picked. Check the login, and only if it is missing, sign in once. Skip the provider you are not using.

   # Claude Code
   claude auth status
   claude auth login
   # Codex
   codex login status
   codex login

5. Pick a starter team and preview it. Use first-project for two Codex agents, first-project-claude for two Claude agents, or first-project-mixed for one of each.

   cd /path/to/your/repository
   starter=first-project  # or first-project-claude or first-project-mixed
   rig specs preview "$starter" --kind rig
   rig up "$starter" --cwd . --plan

6. Launch the team and open the dashboard. To leave the dashboard running, press Ctrl-b then d.

   rig up "$starter" --cwd .
   rig tui --shared

7. Confirm both seats are ready. Answer any authentication, trust or permission prompt a seat shows before giving it work.

   rig ps --nodes --rig "$starter"

8. Give the owner one real change and follow it. Replace the placeholder with a small, checkable change in your repository.

   rig send "dev-owner@$starter" 'Implement <one useful change>. Track the task in the queue and return its ID. Keep it local, verify the behavior, ask dev-check in this rig to check the exact candidate, and record the result and how I can try it.'
   rig queue list --destination "dev-owner@$starter" --limit 1000

What is OpenRig and why is it trending?

The README's own one-liner is the clearest description: a harness wraps a model, a rig wraps your harnesses. If you have ever run three Claude Code windows side by side and copied text between them, OpenRig is the system that replaces your clipboard. You define a topology in YAML, called a RigSpec, made of pods (groups of related agents) and seats (stable roles with an address like dev-owner@first-project). One command starts every seat in its own tmux session, writes the startup files each agent needs, and waits for them to report ready.

RelatedCloudflare Security Audit Skill Setup: AI Pen Test Any Repo

The useful part is what survives. A seat keeps its identity even when the conversation inside it is replaced. Work lives in a durable queue rather than in chat scrollback. rig down --snapshot captures the whole team and rig up <name> brings it back after a reboot, reporting per seat whether it resumed or started fresh. Agents talk to each other with rig send, rig broadcast and rig chatroom, and an MCP server lets them grow or shrink their own team with tools like rig_up and rig_send.

It is trending because multi-agent coding has moved from demo to daily habit, and most people are still doing it by hand. Anthropic's own options, subagents and the experimental agent teams feature, live inside Claude Code and only coordinate Claude. OpenRig's pitch is that you can put Claude Code and Codex in the same team, pair one model's work with the other's review, and keep that team running on your own machine. Version 0.6.3 shipped on 30 September with a fix for messages to Claude seats, and the project has been releasing steadily since it started in April.

How do you install OpenRig on macOS?

Install Node.js 22 first; the README specifically says Apple silicon Macs should use 22 rather than 24 because of a known compatibility limitation. Then run npm install -g @openrig/cli, which pulls a package of about 22 MB unpacked. Its postinstall script checks your Node version and that the SQLite module loads, and it refuses Node 20 with an explanation. If you prefer Bun, bun add -g @openrig/cli works, but OpenRig still runs on Node, and Bun may block that postinstall check.

On a Mac, applying rig setup (without --dry-run) goes further than you may want. It attempts to install missing tools, writes an OpenRig block into ~/.tmux.conf for mouse support and scrollback, and can install cmux and enable its automation socket. rig setup --full adds jq and gh. None of this is required if you already have tmux and one working agent CLI, which is why the getting-started guide treats it as optional.

How do you install it on Linux, and what about Windows?

Linux follows the same path: Node 22 or 24, tmux from your distribution's package manager (or let rig setup attempt it), then the npm install. If you are coming from Node 20, switch first and reinstall, exactly as the README shows:

nvm install 22          # or 24; fnm or your package manager work the same way
npm install -g @openrig/cli
rig --version

Your existing OpenRig data is reopened in place by the new SQLite binding. Windows users have no supported route today. The README is explicit that native Windows is not supported and WSL2 has not been tested, so treat a WSL2 install as an experiment rather than a setup you can count on. We checked on a Windows 10 laptop with Node 24.17: the npm package installs cleanly, rig --version reports 0.6.3 (8b5e9488), and rig setup --dry-run prints its full plan, including every config file it would touch. But rig daemon start stops immediately with "tmux was not found in PATH", and every command that needs the daemon, such as rig specs ls, goes no further. When something goes wrong on any platform, rig doctor inspects system health and both it and rig setup accept --json, which makes it easy to paste the result into an agent and ask what to fix.

RelatedECC Setup: Install the Claude Code Agent Harness in 10 Minutes

How does OpenRig compare with the alternatives?

What are the gotchas before you rely on it?

Read the README section on what OpenRig changes on your machine before you launch anything, because it is unusually candid. Managed startup writes workspace trust and onboarding completion into ~/.claude.json, adds a status-line command and activity hooks to the workspace's .claude/settings.local.json, and can set permissions.defaultMode to acceptEdits. On the Codex side it edits ~/.codex/config.toml, enables hooks and marks the workspace trusted. The daemon also seeds a discovery skill into ~/.claude/skills. The project says plainly that this is not a complete rollback guarantee, so the backup in step 2 is not optional.

Permissions are the second thing to think about. By default YOLO is off: Claude seats launch with acceptEdits and Codex seats with a workspace-write sandbox, which normally blocks network access, including to the local OpenRig daemon itself. The setup flow asks once whether agents may run rig commands without repeated prompts. Saying yes is convenient, but it covers every rig command, including starting and stopping agents. Full bypass exists per seat with rig seat set-permissions, and it should stay a deliberate choice.

Finally, cost and capacity. Every seat is a real agent session drawing on your plan, so a seven-seat product-team uses your limits several times faster than one window. The two-seat starter is the right place to begin, and the bundled conveyor, adversarial-review and research-team specs, listed by rig specs ls, are worth trying only once the pair is earning its keep.

Our take

OpenRig is the most coherent answer we have seen to a problem a lot of developers are solving with tmux panes and copy-paste. The owner-and-checker starter is a smart default: one agent does the work, a second agent, ideally on a different model, checks the exact candidate, and the queue keeps a record of both. The documentation is careful, sometimes to the point of being dense, and it tells you exactly what it writes to your machine, which earns trust. The costs are real too: macOS or Linux only, a noticeable footprint in your Claude and Codex configs, and token usage that multiplies with every seat. If you already pay for Claude Code or Codex and run more than one session at a time, back up your configs and give the two-seat pair one real task this week. If you are on Windows, bookmark it and wait.

Original analysis by GenZTech, based on the OpenRig repository, its getting-started guide and v0.6.3 release notes, and the project's published comparison pages.