29 Sept 2026

Agentic Harness Explained: Multi-Agent Team Management with OpenRig

Yesterday we discussed Hermes. Hermes brings together the tools and management you need to run a single agent—from ChatGPT conversations to web service integrations. Hermes is broad in scope—it can manage any kind of agent.

Today we look from another angle. In software development, you often need multiple coding agents. Claude Code writes one thing, Codex does another, and both work from the same repository on the same project. How do you orchestrate this? How many terminals will you open? How does one agent’s output flow to another? Who is responsible for what if someone fails?

OpenRig is the answer.

Multi-Agent Team vs. Terminal Sprawl

A common scenario in software development:

Morning. Five terminal windows on the developer’s machine.

Terminal 1: Claude Code is writing.
Terminal 2: Codex is reviewing.
Terminal 3: A human runs a script.
Terminal 4: Comparing git logs.
Terminal 5: Investigating a problem’s root cause.

Machine reboots. Terminal windows close. Context is lost. Who was doing what? Which change came from which agent? Is an agent stuck in a deadlock?

OpenRig manages this. You open it, it snapshots. You close it, it saves state. You open it again, it resumes from where it was.

Without a harness, agents are terminal sprawl. With a harness, they are a team.

What Is OpenRig?

OpenRig is an open-source multi-agent harness. A rig (team) is defined in YAML.

# rig-spec.yaml
rig:
  name: "blog-development"
  pods:
    - name: "writer"
      harness: Claude Code
      model: Claude 3.5 Sonnet
      context_size: 200k
    
    - name: "editor"
      harness: Codex
      model: Claude 3.5 Sonnet
      context_size: 100k

  edges:
    - from: "writer"
      to: "editor"
      type: "review"

Then:

rig up blog-development --cwd .

OpenRig starts tmux sessions, gives each agent a “seat,” sets environment variables, binds them to the project, and they all work from the same repository.

OpenRig’s Core Features

1. Team definition in YAML. Define the team as code — keep it in version control. The question “who is on the team now, which models, which connections?” is answered by git log.

2. Connections and flow. Agent A’s output goes to Agent B. Define who works, who waits for results, who can veto.

3. State persistence. Close an agent’s session, its state is saved. Open it hours later, that context is still there. Chat history, completed work, error logs — all persistent.

4. Terminal management. OpenRig manages terminal panes with tmux. Each agent gets its own pane. Look at the screen: who is active, who is waiting, who hit an error — all visible.

5. Observability. Every step an agent takes, its output, its error messages — all recorded. If an agent fails, its full history is traceable.

6. Multiple harness support. Claude Code, Codex, other software agents — they can all join the same team. All managed by OpenRig.

Scenario: Software Development Team

You have a blog, you write articles. You use two agents:

Writer Agent (Claude Code): Writes the article.
Editor Agent (Codex): Reviews the writing, provides improvement suggestions.

In OpenRig, it looks like this:

rig:
  name: "blog-team"
  pods:
    - name: "writer"
      harness: Claude Code
      model: Claude 3.5 Sonnet
    
    - name: "editor"
      harness: Codex
      model: Claude 3.5 Sonnet

  edges:
    - from: "writer"
      to: "editor"
      type: "review"

Morning:

rig up blog-team --cwd /path/to/blog
rig tui --shared  # Terminal UI opens

On your screen, a status table of two seats appears:

Seat	Runtime	Model	Status	Context
writer	Claude Code	Claude 3.5	Running	45k tokens
editor	Codex	Claude 3.5	Waiting	0

You give the writer a task:

rig send writer@blog-team "Write an article about OpenRig"

Writer starts, writes the article. OpenRig records the output.

When the article is done:

rig send editor@blog-team "Review the article from writer and provide feedback"

Editor receives writer’s output (OpenRig automatically wires them together), reviews, writes feedback.

If the machine reboots, all this history is recorded. Resume tomorrow:

rig up blog-team --cwd /path/to/blog

OpenRig restores the previous state or final context. The team resumes where it left off.

Why Is This Critical in an Organization?

If a company runs 10 software agents, each is terminal sprawl. OpenRig turns that into a 10-seat, well-defined team.

For a manager:

Who did what?
Which agent owns which task?
If an agent made a mistake, what’s its history?

With OpenRig, you see the team’s state in a table. History is permanent. Decisions are traceable.

The fact that it is open source matters. You can read the code, add your own agents, adapt it to your infrastructure.

Cloudflare Durable Objects, AWS Lambda vs. OpenRig

Cloudflare Durable Objects manages a single agent. AWS Lambda is stateless. OpenRig is open source and self-hosted — it runs on your infrastructure.

Long term, managing agents on your own systems is cheaper and more controllable.

Conclusion

OpenRig is the harness that turns AI agents into a “team” in software development. Instead of terminals, you have a defined, auditable, persistent system.

Choosing one of these four open-source harnesses (Hermes, buzz, Cloudflare OS, OpenRig) is the first step to keeping agents organized. Each harness focuses on a different domain — Hermes is general-purpose, OpenRig focuses on software development — but they all rest on one principle: agents are not tools; they are entities that need a harness to manage them.

Beyond harnesses, you need to define agents in your organization chart, write policy files, and keep delegation records. agentic-organization is exactly that: a self-hosted, file-based system where you define agents as long-term organizational entities in your org chart. While OpenRig manages a session’s team of agents, agentic-organization institutionalizes agents as permanent members of your organization.