OpenRig vs Claude subagents

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.

Claude subagents started from: what if the lead Claude could delegate focused side-work to specialist agents, each with their own context window, so the noisy work stays out of the main conversation? The answer is a delegation primitive inside Claude Code. The lead spawns a subagent with a specific task, the subagent works in its own context, and the summarized result comes back to the lead. The unit of work is a delegated task.

OpenRig started from a different question: what if Claude Code and Codex are already extraordinarily capable, and what I actually want is to run several of them together as a coordinated team? The answer is a topology-first system. Each agent has its own session, each its own context, each addressable as a peer. They coordinate directly. The unit of work is the rig.

Neither answer is obviously right. Subagents bet that the useful primitive is lead-directed delegation: the lead keeps the plan and the context, specialists handle focused chunks and report back. OpenRig bets that the useful primitive is persistent peers: each agent outlives any single task, and they coordinate across sessions rather than reporting up.

Both systems give each agent its own context window. The interesting difference isn't context isolation — it's what the agents are to each other. A few things fall out of treating them as peers rather than workers:

• Agents send to each other, not up. In a rig, the dev agent can ask the review agent a question directly. A subagent reports back to its lead. If you want coordination that doesn't route through a single lead, peers are the shape.
• You save the whole rig and come back to it. rig down snapshots the topology; rig up <name> brings it back. The rig outlives any one agent's context window. Subagents are scoped to their lead's workflow — they can run in the background, be resumed by agent ID, and carry persistent memory via the memory field, but they remain subordinate to a lead session.
• Agents are addressable by name, not by delegation. You attach to any pane and talk to the agent directly. You don't have to route the message through a parent to reach it.
• Codex can sit next to Claude Code. Subagents are a Claude-inside-Claude primitive. A rig is cross-runtime by design — an implementation agent on Claude Code, a reviewer on Codex, a terminal service node, all in the same topology.

They compose cleanly, though. A Claude Code session that happens to be a node in an OpenRig rig can still use subagents internally to keep focused work out of its main context. The subagent is keeping the node's conversation clean; the rig is coordinating across nodes. Different layers, same workflow.