OpenRig
a control plane for multi-agent coding topologies
Last verified:
What is OpenRig?
OpenRig is an open-source local control plane for building, running, and persisting multi-agent coding topologies; it lets you define a team of coding agents in a single YAML file, boot the entire topology with one command, visualize the running graph, and snapshot/restore the state so your agent topology survives reboots. The tool targets developers, researcher-operators, and engineering teams who compose multiple LLM-based agents (for example Claude Code, Codex, or local models) into cooperating pods and need reproducible, local orchestration without relying on external managed services. Key features include discovery of existing agent sessions (fingerprinting tmux/shell sessions), a CLI to boot and manage rigs, persistent identities and shared memory between pods, and a visualization UI served on localhost for inspecting nodes, edges, and live state. OpenRig emphasizes security and local-first operation: it runs on your machine, supports sandboxing of agent processes, and avoids requiring cloud API keys for the core runtime while providing adapters to integrate external models or tool endpoints when desired.
OpenRig pricing
Pricing model: Freemium
OpenRig is presented as open-source, local-first software with no paid managed plan on the website; core functionality runs on your machine at no cost, while integrations that call hosted model APIs (third-party providers) may require separate API keys and billing with those providers. The project itself does not advertise paid tiers or hosted offerings on the site; installation and runtime components are freely available, and community contributions and ecosystem crates are likewise open-source.
OpenRig pros
- Define entire multi-agent topologies in one YAML file
- Boot a complete rig with a single CLI command
- Snapshot and restore whole topologies to survive reboots
- Discovers and imports existing agent sessions automatically
- Visual, interactive graph UI served on localhost
- Groups agents into pods with shared context for coordination
- Edges explicitly model communication paths between pods
- Runs locally (no required cloud control plane)
- Open-source codebase for auditability and extension
- Cross-harness support for multiple agent implementations
- Persistent identities for agents across restarts
- Tooling to expose OpenAPI endpoints as callable tools
- Lightweight CLI-first workflow for developer ergonomics
- Integrates with tmux/shell workflows to lower adoption friction
- Sandboxing focus to reduce risk of leaking sensitive data
- No mandatory API keys for core features
- Extensible with community crates and plugins
OpenRig cons
- Requires local setup and some CLI/Rust familiarity
- Not a managed cloud service—operator must handle uptime
- Limited turnkey integrations for hosted model providers out of the box
- UI is local-only and not multi-user by default
- Snapshot storage and management policies must be handled by user
- May require extra sandboxing configuration for production safety
- Hardware resource limits (CPU/RAM) affect large rigs
- Documentation is developer-focused and can be terse
- No built-in user access controls for shared network environments
Frequently asked questions about OpenRig
What is a rig and how do I define one?
A rig is a topology of coding agents defined in a YAML file that lists agents, pods, and edges; you author a RigSpec YAML describing pods (groups of agents), their identities, and how they connect, then boot the rig with the CLI to instantiate the topology and the corresponding processes and communication links.
Which agent models and harnesses does OpenRig support?
OpenRig is cross-harness: it runs multiple agent implementations such as Claude Code and Codex and can be extended with community harnesses or local model adapters; support depends on available harness crates or connectors you add to your rig configuration.
How does discovery of existing sessions work?
The rig discover command fingerprints running sessions (for example tmux or shell processes), drafts a candidate RigSpec that maps those sessions into agents/pods, and lets you adopt existing sessions into a rig without rebuilding them from scratch.
How are snapshots and restores handled?
OpenRig can snapshot the topology including agent identities and shared memory, persist the snapshot to disk, and later restore the exact topology so agents keep their state and interaction history across reboots or machine restarts.
Does OpenRig require API keys or cloud accounts?
The core OpenRig runtime is local and does not require API keys or a cloud account to operate, but connectors or tools that call hosted model providers or external APIs will need the relevant API keys and billing set up by the user.
Is the OpenRig UI accessible remotely or multi-user?
The built-in UI is served on localhost for inspecting and interacting with rigs, so by default it is local-only and not designed as a multi-tenant remote dashboard without additional network/configuration work by the operator.
What security or sandboxing features are available?
OpenRig emphasizes sandboxing: it isolates agent processes, encourages local-only operation to avoid data exfiltration, and provides patterns and tooling to compartmentalize agent access to resources, though production hardening and additional OS-level sandboxing are left to the operator.
Can I expose my own APIs or tools to agents inside a rig?
Yes — OpenRig includes tooling (and community crates) to turn OpenAPI specs or local endpoints into callable tools that agents can invoke, enabling rigs to integrate with internal services or custom tooling as runtime-callable tools.
How do pods and edges control communication?
Pods are logical groupings that share context and memory, while edges are explicit connections that define permitted communication paths between pods so you can design and constrain how messages and tool calls flow through the topology.
What are recommended workflows for getting started?
Install the CLI, use a starter rig to see an example topology, try rig discover to import any existing agent sessions you have, iterate on your RigSpec YAML to add pods and tools, and use snapshots to capture stable states you can restore later.