OpenRig

Features

What OpenRig does, one card each. Every card links to the docs for how it works.

46 features

Teams of agents

Define a team of coding agents: their roles, harnesses, models and tools, on one machine or several.

  • Agent teams from one command

    Start a whole team of coding agents with one command. rig up launches every agent in a rig spec, a built-in team or a bundle, each in its own tmux session with a name and a role, and rig down stops them together.

    rig up ./rig.yaml

    How it works →See it →

  • Mixed-harness teams

    Run Claude Code, Codex, Pi and Oh My Pi agents in one team, as the workshop team does with Claude Code and Codex. Each agent's harness is named in the rig spec, and every agent messages the others and works the same queue.

    How it works →Changed in 0.6.5 →

  • Choose a model per agent

    Give each agent the model and reasoning effort its job needs. Set model and effort per agent in the rig spec, and OpenRig passes them to Claude Code and Codex on launch, resume and fork. Pi agents take a model only.

    rig seat set-model <seat> --model <id> --reason "<why>"

    How it works →Changed in 0.6.5 →

  • Roles and delegation

    Give each agent a job and say who hands work to whom. An agent's role comes from its agent spec, and a delegates_to edge sets who launches first and who gets alerted when work sent to that agent stalls.

    rig specs preview factory --kind rig

    How it works →Changed in 0.6.5 →

  • Add agents to a running team

    Add agents to a team while it keeps working. rig grow launches new agents in an existing pod, or in a new one with --new-pod, and rig remove and rig shrink take an agent or a pod back out without stopping the rest.

    rig grow <rig> <name> --pod <pod>

    How it works →

  • Adopt agents you already run

    Bring agents you already run in tmux into a team without restarting them. rig discover finds Claude Code and Codex sessions OpenRig isn't managing and can draft a rig spec from them, and rig adopt brings them into it.

    rig discover --draft

    How it works →

  • Agents across machines and fleets

    Run agents on more than one machine and reach them from one place. Each machine runs its own OpenRig, and paired ones form a fleet: add --host <id> to send, capture, ps and queue create. Use a trusted private network.

    rig host pair http://<address>:7433 --id <name>

    How it works →See it →Changed in 0.6.5 →

  • MCP servers per role

    Give a role the outside tools it needs, declared once with the role. An agent spec can carry MCP server settings, and at launch OpenRig merges them into a Claude agent's .mcp.json or into Codex's config.toml.

    How it works →

  • Docker Compose services with your team

    Start the services your project needs along with the team. A rig spec can name a Docker Compose file, and rig up starts those services, such as a dev server or a database, and waits for their health checks before any agent launches.

    rig env status <rig>

    How it works →Changed in 0.6.5 →

Messaging between agents

Agents send each other messages, read each other's screens, talk in group chats and search what was said.

  • Agents message each other

    Your agents talk to each other directly, whichever harness each one runs. rig send types a message into another agent's terminal and presses Enter, signed with who sent it, and won't type over an agent waiting at a permission prompt.

    rig send <seat> "message"

    How it works →See it →Changed in 0.6.5 →

  • Read any agent's screen

    See what any agent is doing without switching terminals. rig capture prints the last lines of an agent's screen, or of every agent in a pod or rig at once, so you and your agents can check on each other.

    rig capture --rig <rig>

    How it works →

  • Chatrooms and broadcasts

    Talk to a whole group of agents at once. Each rig has a chatroom that agents post to with rig chatroom send and read back or wait on, and rig broadcast types one message into every agent in a rig or pod.

    rig broadcast --rig <rig> "message"

    How it works →

  • Search what your agents said

    Find what an agent said without scrolling back through its terminal. OpenRig keeps the last 1,000 lines of each agent's screen on disk. rig ask <rig> "<question>" matches its keywords across every agent and the rig's chatroom.

    rig transcript <seat> --grep "<pattern>"

    How it works →Changed in 0.6.5 →

  • Pause messages to an agent

    Work in an agent's terminal yourself without messages landing in your draft. Turn on an agent's typing guard and OpenRig saves automatic messages and reminders for it in an outbox instead, which you read with rig seat held-messages.

    rig seat set-typing-guard <seat> --enabled true --reason "<why>"

    How it works →Changed in 0.6.0 →

Long-running agents

Agents that keep working for weeks: recovery after a restart or reboot, context compaction, replacing an agent in the same role, and forks.

  • Restore after a restart or reboot

    Stop your team or reboot, then pick up each agent's conversation where it was. rig up <rig> restores from the newest snapshot and resumes each conversation, and rig restore-check says first whether a rig would come back.

    rig restore-check

    How it works →Changed in 0.6.5 →

  • Swap in a fresh agent

    Swap in a fresh agent when one runs out of room, without losing its work. rig handover starts a new agent in the same role and terminal with a packet of what the last one was doing, and work sent to that role still reaches it.

    rig handover <seat> --reason "context full" --dry-run

    How it works →Changed in 0.6.4 →

  • Fork or save a live agent

    Split a busy agent in two, or save it to start more like it later. rig fork starts a new agent as a native fork of the agent's Claude Code or Codex conversation, and rig agent-image create saves one as a named image.

    rig fork <seat> --rig <rig> --pod <pod> --member <new-name>

    How it works →

  • Managed compaction for Claude

    Long-running Claude agents pick their work back up after compaction. When an agent's context passes 80%, OpenRig has it write a restore map, sends /compact, then has it read the map back. It's off by default. The command below turns it on.

    rig config set policies.claude_compaction.enabled true

    How it works →Changed in 0.6.5 →

Tasks and workflows

Assign tasks to agents, hand them on, schedule follow-ups, and run multi-step workflows with review and sign-off.

  • Assign tasks to agents

    Give a task to one agent and track it until it's finished or passed on. Each task is a queue item assigned to one agent, with a history that survives a busy agent, a compaction or a restart. rig queue handoff reassigns it in one step.

    rig queue handoff <id> --to <seat>

    How it works →See it →Changed in 0.6.5 →

  • Timers that wake your agents

    Set a task aside until a time or an event, and have its agent woken when it's due. A task can wait on a timer, another task or a watchdog, and the daemon types the reminder into the agent's terminal, since agents can't wake themselves.

    rig queue block <id> --on <blocker> --wake-after 2h

    How it works →Changed in 0.6.5 →

  • Find stalled tasks

    Find agents that stopped while they still have open tasks. rig parked lists agents that are idle or at a prompt with tasks assigned, and every 5 minutes the daemon checks for stalled or unclaimed tasks and alerts whoever should act.

    rig parked --rig <rig>

    How it works →Changed in 0.6.5 →

  • Workflows your lead agent runs

    Your orchestrator agent runs the work, and OpenRig keeps it on track. A workflow spec names the steps and their owners. Each step is a task, the next opens only when it closes, and a failed or overdue step goes to the orchestrator.

    rig workflow run <spec.yaml> --root-objective "<goal>" --created-by <seat>

    How it works →See it →

  • Required steps for every mission

    Write down how your project ships once, and every mission follows it. Required steps in project.yaml and each mission's own steps compile into one workflow you can inspect. Missions can add steps but not drop or reorder required ones.

    rig workflow compile <mission-folder>

    How it works →

  • Sign-off before work is done

    Work counts as done when someone you named accepts its proof, not when an agent says so. Agents attach evidence with rig proof add, and only reviewers in your proof policy can accept it. Marking the task closed doesn't count.

    rig proof show <mission>

    How it works →See it →Changed in 0.6.4 →

Workspace and context

Projects, missions and tasks are files on disk that your agents read, along with context, skills and what each role has learned.

  • Work plans as folders

    Your team's plans and progress are folders and files you can read, edit and commit. rig scope creates each mission as a folder of work items, each with a spec, a progress log and proof, and OpenRig's views read those files directly.

    rig scope slice create <mission> <slug>

    How it works →See it →Changed in 0.6.5 →

  • Project context for every agent

    Every agent that joins learns what your project is for, how it works and which skills it uses. A workspace's project.yaml declares its intent, context files and skills, and rig context work-install delivers them to the agent.

    rig context work-install --runtime codex

    How it works →See it →Changed in 0.6.5 →

  • Shared knowledge every agent starts with

    Every agent starts from the same picture of how OpenRig works and what your project is for. rig context profile world-public serves OpenRig's own world, and world-example is a template for writing your project's.

    rig context profile world-public --situation fresh

    How it works →

  • Context on demand

    Your agents load the docs they need when they need them, down to a single section. rig context get serves a context pack, one file or one heading, and rig context add installs your own packs, including from a Git repo.

    rig context get help

    How it works →See it →Changed in 0.6.5 →

  • Skills delivered to each agent

    Each agent gets the skills its role and your project call for. At launch OpenRig copies the skills an agent spec or a project.yaml selects into .claude/skills/ or .agents/skills/, so Claude and Codex agents share one set.

    How it works →Changed in 0.6.2 →

  • Knowledge that outlasts the agent

    What agents learn stays with the position, at every level. A LEARNED.md can sit at the instance, rig, pod and agent level, rig context trace walks that chain for an agent, and a rebuild handover primes a fresh agent from it.

    rig context trace --rig <rig> --seat <seat> --name LEARNED.md

    How it works →

Operations and permissions

What agents are allowed to do, what they use, and checking that OpenRig itself is healthy.

  • Permissions per agent

    Choose how much each agent can do without asking. Team agents run rig, read and test commands without a prompt, and Claude Code agents still ask before starting or stopping teams. builtin:yolo or this command gives full bypass.

    rig seat set-permissions <seat> --mode full_bypass --reason "<why>"

    How it works →Changed in 0.6.6 →

  • See usage limits and resets

    See how close your Claude agents are to their usage limits. rig provider status shows the 5-hour and weekly use Claude reports, flags 80% as nearing, and shows when a limit resets. It needs Claude Pro or Max. Codex shows as unknown.

    rig provider status

    How it works →Changed in 0.6.5 →

  • Token use per agent

    See which agents are using the most tokens. rig usage top ranks agents by tokens per hour over a window you choose, and shows each one's Claude limit use. An agent with no recent sample shows as unknown, not as zero.

    rig usage top --window 2d

    How it works →Changed in 0.6.5 →

  • Health checks and diagnostics

    Find out what's wrong without digging through logs. rig doctor checks the install, rig health keeps health findings you can ask it to explain, and rig crash-cart gives a recovery verdict as JSON when the daemon is down.

    rig doctor

    How it works →

  • A built-in team that runs OpenRig

    Ask OpenRig's own agents to run OpenRig for you. The daemon boots a kernel team on your logins: an advisor turns what you want into a team plan, and an operator brings rigs up, back after a reboot and through upgrades.

    rig send operator-agent@kernel "bring my rigs back online"

    How it works →Changed in 0.6.5 →

Oversight and decisions

What needs your attention comes to you: decisions, live status, the dashboard, terminal views and Slack.

Run it your way

Install it, use the logins you already have, start from a template, and share a team as a file.

  • One npm install, macOS and Linux

    Install OpenRig with one npm command on macOS or Linux. You need Node.js 22 or 24, tmux, and Claude Code or Codex signed in. rig preflight checks Node, tmux, the daemon port and state folders, and rig doctor checks the install.

    npm install -g @openrig/cli

    How it works →Changed in 0.6.5 →

  • Uses your existing subscriptions

    Your agents run on the Claude Code and Codex logins you already have. OpenRig starts the real CLIs in tmux on your own subscription. It's open source (Apache 2.0) and self-hosted, and there's no OpenRig account.

    How it works →Changed in 0.6.5 →

  • Three teams to start from

    Most people should start with workshop: a lead, a builder, QA and a reviewer working in your repository, installed from the rigs page. New to agent teams? starter is one builder and one reviewer. factory runs seven agents for bigger work.

    How it works →See it →

  • Define a team in YAML

    Describe a team in a YAML file you can keep in git. A rig spec lists pods, agents, runtimes, models and edges, and rig up ./rig.yaml launches it. rig spec validate checks it without a daemon. rig export writes a running rig to YAML.

    rig spec validate ./rig.yaml

    How it works →Changed in 0.6.5 →

  • Share a team as one file

    Hand someone a whole team as one file. rig bundle create packs a rig spec with the agent specs it uses, their skills and startup files, and a SHA-256 digest. rig up team.rigbundle --target <folder> installs and launches it.

    rig bundle create ./rig.yaml -o team.rigbundle

    How it works →Changed in 0.6.4 →

  • Drive OpenRig over MCP

    Use OpenRig from any MCP client. rig mcp serve runs a stdio MCP server with 18 tools that start and stop rigs, list agents, send messages, read screens and use chatrooms. Queue work isn't among them, so agents use the CLI for it.

    rig mcp serve

    How it works →

As of OpenRig 0.6.6.