OpenRig: Persistent Coding-Agent Teams and Handoffs

Many Claude Code or Codex windows can make task ownership hard to track. OpenRig addresses that coordination problem with named roles, addresses, ownership, and durable handoffs. This article examines the architecture, use cases, and limits before setting up a multi-agent team.

Several AI-team networks connected through a central hub that hands off work in sequence, representing OpenRig's multi-agent coordination

What is OpenRig and what problem does it solve?

OpenRig is not a new AI model, nor is it an agent framework that directly replaces Claude Code or Codex, but it serves as control plane or multi-agent harness that coordinates multiple harnesses, turning separate agent terminals into a structured team with roles, identities, handoffs, and inspectable status

The key idea is that each agent should be more than a temporary process disappearing when a session closes; it should have seat or a named, persistent role such as implementation, QA, review, or research agent. The seat remains after its session ends and can accept a new session to resume from saved context.

OpenRig is therefore suitable for problems that arise when we use more than one coding agent at the same time, such as who owns this work, who needs to continue reviewing it, where is the pending work? If the agent context is full and the session is changed, how will the work be forwarded? And how to make Claude Code and Codex work together without having humans copy-paste context between terminals all the time?

Architecture: tmux is the communication channel, while SQLite and files are the source of truth

OpenRig's architecture documentation explicitly explains that tmux is a transport, not a source of truth. tmux accesses agent terminals, sends messages, and reads output. Durable rig/task state and transition history reside in SQLite and files. When terminal output conflicts with database state, OpenRig treats the database as authoritative.

OpenRig combines a local daemon, user CLI/TUI, MCP tools for agents controlling topology, SQLite persistent state, and adapters for harnesses such as Claude Code or Codex. It retains original agent terminals and allows tmux attachment to observe actual work when needed.

Unlike orchestration systems hiding everything behind an API, OpenRig recognizes that many practical coding agents already live in CLIs. It builds a control plane around those terminals instead of forcing whole workflows into a new runtime.

Rig, Pod, Seat, and AgentSpec: The basic units of an “AI enterprise”

The important point is that OpenRig separates the “role identity” from the “running session”, similar to a real organization where the Backend Engineer position remains even if the original employee leaves. In the agent world, this helps keep the system from tying all knowledge and work to a single context window.

OpenRig TUI demo image showing rig factory divided product dev qa and seats such as lead design app data ui and test along with relationship lines.
OpenRig developer demo showing rig → work group → seat hierarchy and connections. It is neither a KrobClick-run team nor the starter product-team below. Topology lines do not establish permission enforcement. Source: OpenRig repository, Apache-2.0 Converted PNG to WebP without content changes. Click for full size.

Queue ensures that work transfers don't get lost in chat.

Sending a message to another agent using rig send Suits questions and notifications, but messages alone do not establish task ownership. With multiple agents, messages may be buried in history or leave responsibility for the next step unclear.

OpenRig's queue holds owned work items, each with a destination seat, task content, state, and append-only transition history. Work persists through completed turns, context compaction, or replaced sessions. A handoff can close the sender's item and open its successor for the recipient in one transaction, reducing gaps between agents.

However, OpenRig's documentation warns that durable doesn't mean automatic Queues record ownership and work history, but do not guarantee agents wake and notice tasks. Notifications, watchdogs, or human/peer prompting may still be needed.

Workflow and Watchdog: When task handover must be in a repeatable sequence

If queue is “Who holds this piece?” workflow is “What steps should the piece go through?” For example: Planner → Implementer → QA → Reviewer. The system keeps the active step and owner in a durable state. When the owner closes a step, the system can create a queue item for the next step in a single transaction.

Watchdog is a mechanism that helps manage timing and waiting because agents do not always wake up. Watchdog jobs are stored in the database and remain after daemon restart. They can be used to warn based on time, wait for artifacts, wait for queue to become available, or monitor seat context usage before hitting context walls.

Combining rigs, queues, workflows, and watchdogs creates something closer to a “software factory”: people need not remember every handoff, while traceable state shows the current workflow stage.

Continuity: Why is OpenRig different from running multiple agent windows?

The problem with coding agents that work for a long time is that the context window is limited. The session may crash, the process may close, or the machine may restart. OpenRig separates the seat from the session, thus creating a continuity mechanism to try to maintain the work to continue, such as snapshot/restore the entire rig, handover of the seat, restore brief, and preparation before compaction.

A useful principle is honest restoration reporting: do not say “restored successfully” if the agent actually restarts without context. Documentation labels each seat resumed, rebuilt, fresh, or failed so operators know its actual state.

Use Case 1: Product Team for developing end-to-end features.

Starter product-team OpenRig's example has 3 pods and 7 seats across orchestration, development, and review. Development includes implementer, QA, and product designer; review has two independent reviewers. It separates building from checking instead of one agent reviewing its own code.

This format is suitable for full-stack work with many requirements, such as adding a new subscription system: an orchestrator helps break down work, an implementer does backend/frontend work, a designer checks UX, QA tests user flow, and a reviewer checks architecture or regression before finalizing and letting humans make decisions.

The advantage is not in the number of agents, but in Clear separation of concerns and handoff points OpenRig itself advises that refactoring one module does not require 7 seats. Start with one or two agents and expand topology when coordination has actual value.

Use Case 2: Implementation + QA for a small team that needs a "doer" and a "checker"

If product-team is too large, OpenRig has a starter implementation-pair for implementer and QA specifically. This suits solo developers who want simplicity without making one coding agent both the builder and the certifier of its own work.

For example, have the implementer fix a bug in the checkout flow and handoff it to QA to test acceptance criteria, edge cases, and regression. If QA finds a problem, work can be sent back to the implementer with a more specific context. This format has lower overhead than product-team and is a good starting point for those just experimenting with multi-agent.

Use Case 3: Adversarial Review Let two models find different points of failure.

OpenRig has starter adversarial-review It separates the lead from two independent reviewers, and the guidelines in the document support mixing different runtimes. The aim is to avoid reviewers sharing the same biases.

The project's Claude vs Codex manual states from the creator's experience that Claude and Codex often have different strengths and failure modes, making them suitable for examining the same work from different angles. Although the observation “Which model is good at what” can change according to the model. But the broader principles are still interesting: Reviewer diversity is valuable when the types of errors do not overlap.

This suits important pull requests, migrations, authentication, permissions, or other high-confidence code review. Reviewers inspect independently before the lead combines findings.

Use Case 4: Research Team separates “finding information” from “synthesizing conclusions”.

OpenRig has starter research-team Consisting of lead, analyst, and synthesizer, this format is not limited to writing code. Because many problems in software work begin with finding answers, such as comparing libraries, evaluating architecture, analyzing incidents, or exploring new APIs.

Separating analyst and synthesizer lets one focus on evidence while the other checks consistency, assesses trade-offs, and writes recommendations. This reduces attachment to the researcher's initial assumptions.

For a real team, extend this to multiple analysts covering security, performance, cost, and developer experience, then have a synthesizer report findings and remaining uncertainties to the lead.

Use Case 5: a specialist staying with a project for months without repeated explanations

OpenRig's website highlights an interesting use case: “Ask the specialist.” When a project accumulates months of decisions, some seats may know a subsystem better than a newly created agent, such as the agent responsible for a shared client, database schema, or deployment pipeline.

Persistent seats retain roles and saved context instead of receiving all documents in each new agent session. Other agents can ask specialists directly. A short question may use a message without creating another queue item.

This suits large codebases with domain knowledge across frontend, backend, data, infrastructure, and security. Topology clarifies whom to ask instead of expecting one agent to know everything.

Use Case 6: Agent-Managed Software — Let specialists actually take care of the service.

OpenRig does not restrict rigs to agents alone. RigSpec supports managed services through Docker Compose; one provided example is secrets-manager which uses HashiCorp Vault with specialist agent

Here agents also operate software packaged with a rig, such as checking health, reading status, or following runbooks. Possible uses include database operators, local test environments, observability stacks, and internal tools with dedicated agents. Production use requires careful permission and guardrail design.

Use Case 7: Architecture Roundtable and cross-team decision making

“What is a rig?” describes agents from multiple pods forming a tiger team for architecture discussions: implementers bring code constraints, researchers technology findings, and reviewers failure modes.

This goes beyond querying a model repeatedly: agents with context from different domains exchange information, then return to their original seats after the decision. It suits questions without a single answer, such as choosing a database, designing permission boundaries, splitting services, or planning a migration.

Use Case 8: Dogfooding and Recursive Improvement Loop

OpenRig's creators say they used to connect the build rig, product-management rig, and dogfood rig together, letting the dogfood system send feedback back to product management and looping back into development, creating a recursive self-improvement model of the software.

This case shows the potential of having workflows, persistent teams, and watchdogs, but it's also where we need to be most careful. The creators themselves stated that they later reduced the level of autonomy because they needed a better guardrail before releasing a loop like this to a public project. This is an important lesson: multi-agent orchestration really does make agents work continuously, but the longer the loop, the more important it is to control intent, permission, and acceptance criteria.

Use Case 9: Simulated Focus Group for UX and Product Discovery

OpenRig documentation also suggests non-coding patterns: one agent demonstrates a product, another plays the user, and a third observes and reports. Repeating this can reveal patterns of friction or misunderstanding.

This should be viewed as simulation to create hypotheses It does not replace research with real users: agents lack human experiences, needs, and limitations. It may quickly broaden exploration of edge cases before usability tests or help create dogfooding checklists.

How much is it actually used? Evidence from the Community Field Report.

Beyond creator examples, GitHub Issue #227 contains one user's field report of OpenRig v0.6.2 running for 3 days across two hosts, with a 9-seat development factory and kernel rig. It used an OpenCode adapter cherry-picked from an unmerged PR. Unattended operation worked to an extent, but the user reported several operational gaps requiring manual fixes.

This suggests persistent fleets can work beyond demos, but the OpenCode adapter is not a standard OpenRig feature: the reporter used a branch with manually integrated experimental code. That setup does not certify normal-release stability.

How is OpenRig different from Subagent?

Subagents within Claude Code or other harnesses are often suitable for temporary subtasks: the main agent breaks the work down to a helper to find files, write tests, or analyze parts. Then bring the results back together in the original session. OpenRig does not replace this mechanism. But add another layer for Agent that should have identity and long-term ownership

OpenRig describes durable specialist seats that can each call temporary native subagents. Both levels can coexist: OpenRig organizes the main team with ownership and queues, while subagents handle short subtasks within each specialist's context.

A short subtask needing no owner after its session usually suits a subagent. A recurring role with decision history, discoverability by other agents, or cross-day handoffs starts to justify an OpenRig seat.

OpenRig's strengths

Local-first here describes the team control plane and work state, not a guarantee that prompts or code stay on-device. The Architecture documentation says coding harnesses use their configured providers. Review each seat’s data path, including MCP, telemetry, and supporting services, before allowing access to internal code or documents.

Limitations and risks that you should know before using

OpenRig is still a pre-1.0 project, and the maintainers have stated that rough edges can be expected. The first constraint is operational complexity: when there are multiple seats, the problem is not just “agent answers incorrectly” but also queue freezes, context drift, model throttling, startup configuration, and incomplete handoffs.

On the environment side, current documentation focuses on macOS and Linux with supported versions of Node.js and tmux, while native Windows is not yet supported and WSL2 has not been officially tested in the reviewed manual. Additionally, the number of seats running simultaneously increases quota usage and can cause provider throttling to occur quickly, especially with large topologies.

You have to be especially careful about permissions because OpenRig connects the agent to the terminal and can set the runtime to work together. rig setup may change provider configuration and workspace trust files. The documentation recommends reviewing the dry run and knowing which files will change before accepting setup.

Some topology edges describe relationships without enforcing policy. Types such as can_observe, collaborates_with and escalates_to are informational in the current schema. A YAML connection does not itself establish a security boundary or enforce authorization.

Multi-agent systems do not automatically improve correctness. With unclear requirements, several agents may amplify mistakes faster. Review pods, acceptance criteria, proof, and escalation to humans matter more than simply adding agents.

Who should use OpenRig, and who does not need it yet?

OpenRig is suitable for those who are starting to find that the "coordination costs" of many agents are higher than the cost of running models, such as having to copy context between terminals, missing work, not having an independent reviewer, projects dragging on for many days, or wanting specialists to come back and do the same work over again without starting from scratch.

If you still use a single agent to perform short tasks or occasionally open two terminals, OpenRig may be overkill. Because you have to take care of the daemon, tmux, topology, and state more, starting with one agent or pair. implementer+reviewer Then gradually grow according to pain points, an approach that is more consistent with the project's recommendations than starting with a large fleet.

How to try OpenRig with a small team

Hypothetical implementation-pair exercise: Have the implementer fix a CSV reader to preserve the code 00123 then give QA the diff path, sample data, and check results. Acceptance requires leading zeros preserved and other data unchanged. If QA finds the code has become 123 Return failed items with files and conditions; do not close work simply because its creator says it is done. After changing sessions, recheck owners and artifacts against actual state. This is a workflow review plan, not KrobClick's OpenRig test, and grants no automatic push or deployment permission.

A reasonable start is one small task with a clearly verifiable result, such as a minor feature or a single bug. Assign one agent as owner and another as checker, then observe whether the durable queue and seats actually help. Add builders or reviewers when parallel work begins, and create a workflow once repeated handoff patterns emerge.

Before increasing autonomy, define 4 things: the outcome, acceptance criteria, permission boundaries, and escalation points. Without them, more agents can generate output faster without greater confidence that the work meets the goal.

OpenRig organizes ongoing work across agents

OpenRig stands out by treating agents as team members with identity, ownership, communication, continuity, and workflows for ongoing work. Multiple agents alone are not its distinction: Claude Code and Codex already provide ways to create helpers.

Coding with several AI roles requires clear permissions, task ownership, knowledge storage, and a recovery plan when context or processes are lost. OpenRig explores these needs through persistent teams. It currently suits users who can handle the complexity and rough edges of a pre-1.0 system more than general users.

Sources

This article references the OpenRig documentation and sources reviewed at 7 October 2026, where the project is prior to version 1.0. Runtime command details and limitations are subject to change. You should check the documentation for the version you actually installed before using it.