One coding agent is a tool. Five coding agents is an operations problem.
Somewhere around the third terminal tab, the questions change. Which agent is stuck on a permission prompt? Which branch is which? What happens to all of them when I close my laptop? Who reviews whose work?
Three open-source projects each answer part of that, and they answer it at different layers:
- Orca is the cockpit: a desktop app where every task gets its own worktree and its own agent.
- OpenRig is the team: agents with roles, a lead that delegates, and a queue of owned work.
- Herdr is the runtime: a background server that keeps agent terminals alive and knows which agent is stuck.
I set all three up on my Mac and ran real agents on them. Together, they cover a lot. But four things that a fleet of agents needs aren’t covered by any of them, and that’s where this post ends up.
How this was tested. On October 27, 2026, I had Claude Code drive Orca 1.4.242, OpenRig 0.7.4 and Herdr 0.9.5 on my Apple silicon Mac. Orca was installed for the test. OpenRig was already on the machine and was upgraded to 0.7.4. Herdr was already installed. The agents were Claude Code. Every terminal line quoted here is copied from that session. Where I say something is documented but not tested, I mean exactly that. I didn’t test anything across two machines.
The receipts are public. Every claim, every piece of evidence and every checked quote is in Receipts: How the Orca, OpenRig and Herdr Post Was Made.
Three layers. Orca on top is the cockpit: a worktree and an agent per task. OpenRig in the middle is the team: roles, a queue and handoffs. Herdr at the bottom is the runtime: it keeps agent terminals alive and knows which agent is stuck.
The three layers
All three are open source, and all three shipped a release in the last two weeks.
| Orca | OpenRig | Herdr | |
|---|---|---|---|
| Layer | Cockpit | Team | Runtime |
| What it is | A desktop agent IDE with a CLI | Persistent agent teams, defined in YAML | A background server that owns agent terminals |
| License | MIT | Apache-2.0 | Apache-2.0 |
| Built in | TypeScript | TypeScript | Rust |
| Version tested | 1.4.242 | 0.7.4 | 0.9.5 |
| GitHub stars, Oct 27 | about 108k | about 8.2k | about 46k |
| Repo | stablyai/orca | mvschwarz/openrig | herdrdev/herdr |
Orca calls itself “the agent development environment.” Each task runs in its own git worktree with its own agent, beside its terminals, diffs, a browser and an editor. The homepage undersells the CLI. The one bundled with the app has 288 commands, including a full orchestration layer with tasks, dispatch, supervised workers and decision gates.
OpenRig puts it this way: “A harness wraps a model. A rig wraps your harnesses.” You define a team of Claude Code, Codex or Pi agents in YAML and boot it with one command. You talk to a lead agent, and it delegates to specialists through an owned queue. A daemon tracks the team, takes snapshots and can restore it.
Herdr says it’s “where your coding agents live.” It’s a single binary that runs in the background and owns your terminals, so agents keep working when you detach. It labels each agent working, blocked, idle or done. Agents can drive it too: its CLI and socket API let one agent start another and wait on it.
What I ran
I gave each tool a real job on the same small repo: a slugify() function with a failing test. The jobs chain together. OpenRig’s review produced two follow-ups, and those became the parallel tasks I gave Orca.
OpenRig: a team that survived being torn down
OpenRig’s starter team pairs a Claude Code builder with a Codex reviewer. I only had Claude Code set up, so I copied the spec and switched the reviewer to Claude Code. That’s the point of a YAML team. One snag: local: agent references must be relative paths, so I had to copy the agent definitions next to my spec.
Then I gave the builder a bug and asked it to get a review.
The replay: I booted a two-seat team from YAML, both seats waited on a model dialog, I sent the builder a task, it asked to run tests, fixed the bug with a one-line change and handed it to the reviewer through the queue. The reviewer passed it and noted that only one test had been failing, not two as I'd said. I then tore the team down, restored it from a snapshot, and the builder still remembered what it had fixed. Five human approvals in total.
The agents corrected me. My task said two tests were failing. Only one was. The builder noticed, and the reviewer confirmed it on its own: “Only the trim test was failing before the fix, not two tests.” The reviewer also flagged two problems outside the task, and said what it hadn’t checked.
Restore brought back the conversation, not just the processes. rig down killed every agent process. After rig restore, I asked the builder what it had fixed, and it answered correctly, including the reviewer’s verdict. Restarting the OpenRig daemon didn’t disturb the agents at all, because tmux owns them, not the daemon.
It isn’t hands-off out of the box. A one-line fix took five approvals from me. Two were a Claude Code model dialog, which OpenRig flagged as permission_prompt, and three were shell commands. You can loosen that, and OpenRig says plainly that its own kernel already runs with broad permissions by default. Decide that on purpose.
Herdr: who’s working and who’s stuck
I started two Claude agents in a fresh Herdr workspace. One ran in auto mode. The other ran in default mode, so it had to ask before running a command. I prompted both and waited on each with herdr agent wait.
Both agents started idle. About three seconds after its prompt, Herdr reported the auto-mode agent done. About four seconds after its prompt, it reported the other agent blocked on a permission prompt. Herdr's explain command showed the rule it matched for each: bash_permission_prompt and live_prompt_box.
It reads the screen. herdr agent explain shows how Herdr decides. It doesn’t ask the agent for its state. It matches rules against what’s on the terminal, using a detection manifest for each agent. That’s how it supports so many CLIs while, in its own words, it “doesn’t wrap them or replace them.” It’s also why an unfamiliar dialog can slip past. Herdr’s agent guide warns that idle and done don’t guarantee “that an unfamiliar approval dialog was recognized.”
It agreed with OpenRig. An earlier OpenRig install of mine had opened its kernel view inside Herdr. Herdr reported the OpenRig advisor as blocked, matching OpenRig’s own needs-input flag for the same agent.
Orca: two agents in parallel, then the merge
I took OpenRig’s two follow-ups to Orca: transliterate accented letters, and handle titles that produce an empty slug. I ran orca worktree create once per task. Each command made a branch and a worktree, and started a Claude agent there with the task.
Two Orca agents worked in parallel worktrees. Both passed all four of their tests. Merging the first branch was clean. Merging the second conflicted in test_slug.py, because both agents had appended a test to the end of the same file. slug.py itself merged automatically.
Each agent was right, and the merge still failed. Both branches passed all four of their tests. The first merged clean. The second conflicted in test_slug.py, because both agents had added a test to the end of the same file. That’s not an Orca bug. Worktrees did their job: neither agent could see the other’s changes. But that isolation also means nobody sees a collision coming. I searched all 288 commands in Orca’s CLI for anything about conflicts and found nothing.
Two install notes. The Homebrew cask named orca is a different project, Plotly’s chart image exporter, and Homebrew has disabled it. Use the download from Orca’s site or its GitHub releases. The macOS app is signed and notarized under the developer name “Lovecast LLC,” not Stably, and Gatekeeper accepted it.
Choosing and combining
If you work in a terminal and the work fits in a session, use Herdr on its own. If it runs for weeks, use OpenRig with Herdr as its view. If you want a desktop app for parallel tasks, use Orca. If you want a standing team as well, run OpenRig beside Orca, knowing they don't integrate. If you want to talk to a lead agent but the work is short, you probably need just one agent.
- Choose Herdr when the problem is “I have several agents in terminals and I lose track of them.” It’s the smallest step, and it changes the least about how you work. It has no team model, no queue and no memory beyond scrollback.
- Choose Orca when the problem is “I want several independent tasks in flight, and I want to review each like a pull request.” It’s the most complete single app of the three. Expect parallel branches to collide at merge time, and turn on its session search if you want it. It was off on my install.
- Choose OpenRig when the problem is “I want a team that remembers what it’s doing next week.” It’s the only one built around roles, ownership and handoffs, and its restore worked. It’s also the heaviest. On Apple silicon it wants Node 22, and it writes to several config locations. Its README warns that it “doesn’t guarantee it can preserve or roll back these files, so back them up first.”
Here’s what actually connects when you run them together.
OpenRig and Herdr are integrated: OpenRig installs Herdr by default and opens its views there, and Herdr read the OpenRig agents' states correctly. Orca and Herdr are not integrated: Orca runs its own terminals, and Herdr didn't see Orca's agents. I found no link between Orca and OpenRig. And OpenRig's managed CLAUDE.md blocks changed the behavior of a separate agent in the same repo.
OpenRig on Herdr is a real pairing. OpenRig’s setup installs Herdr unless you pass --no-herdr, and it opens its views in Herdr when Herdr is there.
Orca sits beside them, not on top of them. It runs its own terminals and its own orchestration. Pair Orca with an OpenRig team, and you’re running two coordinators that don’t know about each other.
Shared repos mean shared instructions. OpenRig writes managed blocks into your repo’s CLAUDE.md. An ordinary Claude agent I started in the same repo through Herdr began by checking its “rig identity and queue,” though it wasn’t part of any rig.
A map borrowed from Kubernetes
To see what’s missing, it helps to borrow a map. None of these projects calls itself a Kubernetes for agents. OpenRig’s own comparison is “the Terraform for Coding Agents.” But fleets of agents are running into the same problems fleets of containers did, and the Kubernetes stack is a good checklist of what a fleet needs. The mapping below is my lens, not their claim, and the places where it breaks matter as much as where it fits.
Container runtime and kubelet map to Herdr. Control plane and Helm map to OpenRig. Rancher maps to Orca. Longhorn, replicated persistent storage, maps to nothing: no tool provides durable memory shared by every agent.
- Herdr is like the container runtime plus the kubelet. It keeps processes alive on a machine and reports their state. Unlike a container runtime, it isolates nothing. A pane is a shell running as you.
- OpenRig is like the control plane plus Helm. You declare a team in YAML and package teams as bundles. But I saw nothing that keeps pulling the live team back toward the spec, the way a Kubernetes controller does.
- Orca is like Rancher. It’s one cockpit over many workspaces and machines. Unlike Rancher, it also orchestrates on its own, which overlaps OpenRig.
- Nothing is like Longhorn. Longhorn exists because containers are disposable and their data isn’t. Agents are disposable too, and what they learned isn’t.
The k3s versus k8s question maps onto weight. Herdr alone is the k3s-sized setup: one binary, the useful core, little to run. OpenRig is the k8s-sized one. It brings a daemon, a four-seat kernel team, a queue, workflows, a scheduler, snapshots and a host registry, and it touches a lot of your configuration to get there.
What none of them do
Put all three side by side and a pattern shows up.
The capability map. Between them, the three tools cover keeping agents alive, state detection, worktree isolation, teams and queues, restore, multiple machines, session search and scheduled jobs, each to a different degree. Four rows are empty for all three: memory shared across tools and machines, a warning before parallel agents collide, placing work by machine capacity or model limits, and one permission and audit policy across all three.
Every row near the top has at least one answer. The bottom four have none.
No shared memory. Each tool keeps its own record. OpenRig searches one rig. Orca searches one host, and its help says “There is no all-computers search.” Herdr keeps scrollback. An agent in Orca can’t find what an OpenRig team learned last week. Neither can the next OpenRig team on another machine.
No warning before collisions. Isolation is solved. Coordination across isolated work isn’t. My two Orca agents each did the right thing, and the first anyone heard of the conflict was git merge.
No placement that knows about limits. All three can reach more than one machine, at least on paper. None decides where work should run based on how busy each machine is or how much model capacity is left. Orca shows usage and rate-limit resets, but it doesn’t place work by them.
No single policy. Each tool has its own permission model, and each agent harness has another. OpenRig’s policy help is candid about it: it records the posture you choose, and the harness enforces it, “never runtime enforcement.” Nothing gives you one place to say what agents across all three may do, and one log of what they did.
So is there a complete stack for running a fleet of coding agents yet? No. The cockpit, the team and the runtime exist, and they’re good. What’s missing is the memory they share, the coordination between them, the placement of their work and the policy over all of it. Those are what turn a lot of agents into a fleet.
Versions tested: Orca 1.4.242, OpenRig 0.7.4, Herdr 0.9.5, Claude Code 2.1.311, on macOS, October 27, 2026. Star counts are from the GitHub API on the same day. These projects ship fast, so check their release notes before relying on any limitation described here. The evidence for every claim is in this post’s receipts.