One AI agent that writes code is impressive. Two are handy. From three on, you're no longer a developer. You're the mail carrier: copying messages from one window to the next, remembering who knows what, and starting over every time the computer reboots.
That's exactly the problem OpenRig wants to solve. The open-source tool (its source code is free to read and use) turns a pile of separate AI sessions into a standing team. It's built by developer Mike Schwarz and published under the name Esoteric Labs. We've only just started testing it ourselves. And we're so taken with it that it's already worth an article. So this isn't a long-term test: the details come from the website, the docs and the source code.
What OpenRig actually does
Terms first. A coding agent is an AI that doesn't just suggest code but edits files, runs commands and starts tests on its own. The best known right now are Claude Code from Anthropic and Codex from OpenAI. Claude Code, by the way, is what builds this very blog.
OpenRig doesn't replace these agents. It organizes them. Think of Claude Code and Codex as freelancers. OpenRig is the office around them:
- Fixed seats: Every agent gets its own seat with a name and an address. Agents can use it to message each other.
- Clear ownership: A queue makes sure every task has exactly one owner. No two agents tinker with the same task at once.
- Memory for reboots: OpenRig saves snapshots of the team. After a restart, a single command puts everyone back in their seat.
You no longer talk to each agent separately, but to one that keeps the overview and hands out the work. OpenRig ships with ready-made teams. The smallest has two agents, the largest seven.
One builds, one reviews
The small starter team is the most interesting part, precisely because it's so unspectacular. The plan: Claude builds, Codex reviews. Two agents from two different companies: Codex keeps an eye on Claude.
We know that principle from our own practice. On this blog, too, one model writes and another one checks every article before it goes live. Our article about MiniMax shows what that looks like. The reason is simple: a model tends to overlook its own mistakes. A second model, trained differently, is more likely to trip over them.
What does it cost?
OpenRig itself costs nothing. It's under the Apache 2.0 license (a widely used open-source license), runs entirely on your machine and, according to the developer, has neither a cloud service nor a paid tier. The source code on GitHub currently has more than 8,000 stars.
The agents inside it cost money, though, at least once you use them seriously. OpenRig uses your existing access to Claude Code or Codex, usually a subscription with Anthropic or OpenAI. You don't need a separate API key (an access code for programs). For the starter team in its original lineup, you need access to both. According to the website you can still start with just one, but then without the second company's perspective.
And here's the catch: three agents running at once on similar tasks use roughly three times as much as one. You'll hit your subscription's usage limits that much sooner. According to its docs, OpenRig won't step in: the stalled agent's tasks stay in the queue until the limit resets or you reroute them by hand.
Where it creaks
Terminal only. You need the terminal (the window where you type commands), Node.js (a runtime for JavaScript programs), tmux (a program that manages many terminal sessions at once) and macOS or Linux. Windows only works via WSL2, meaning Linux running inside Windows. With tools like these, Linux is usually the more relaxed route.
A lot of freedom for the agents. So the team can work without constant check-ins, the docs say team agents on Claude Code may read project files and run tests without asking. OpenRig's own management crew, which sets up and starts teams for you, gets even more: editing files, fetching web pages, running commands, including reads anywhere in your home folder. The docs say it themselves: these are permissions, not containment. During setup, OpenRig also writes settings and small scripts into your configuration. The guide explicitly doesn't guarantee it can roll those back cleanly. So: backup first.
No reason to panic, but a reason for caution. If you try it, use a separate user account or a virtual machine (a simulated computer inside your computer) and a project that lives in Git (version control that lets you roll back any change). Why that's a good idea is covered in Will AI delete my data?.
Young project, lots of movement. The current version is 0.7.4, released on October 27. The previous one came out the same day. That's not a complaint, more of a heads-up: things are being rebuilt daily. According to the website, even OpenRig's own development is mostly done by agent teams running on OpenRig. In practice, the developer writes, it's like a self-driving car — with a hand near the wheel.
A sentence worth remembering for any AI automation.
Is it for me?
The most honest answer is on OpenRig's own explainer page: if you've never run enough agents at once to feel the group problem, you probably don't need the tool yet.
Beginners: No, at least not yet. OpenRig assumes you already use Claude Code or Codex in the terminal. What you can still take away is the "one builds, one reviews" principle. That works in a perfectly normal chat, too. Have one AI write a text, then give it to another one to proofread:
Here is a text another AI wrote. Review it critically: which claims are questionable, what's missing, what would you cut?
The free tiers of the big providers usually cover that, despite their limits.
Developers already working with Claude Code or Codex: Worth a look. Especially if you catch yourself copying messages back and forth between terminal windows. Start with the two-agent team, in a test project, with a backup. (Unpaid opinion, as always here.)
Everyone in between: Read, remember, check back in six months.
Where this is heading
OpenRig isn't a tool for everyone. But it shows where AI tools are heading right now: away from the single chat window, toward small teams with distinct roles. The interesting question is no longer whether the agents can do it. It's who supervises them.
As things stand, the answer is still: you. With at least one hand on the wheel.