---
title: "Cork vs Herdr: where agents live vs how they share a codebase · Cork"
description: "Cork vs Herdr: Herdr keeps AI coding agents running in persistent terminal panes. Cork keeps those parallel agents from overwriting each other's code."
canonical: "https://corkcli.com/blog/cork-vs-herdr"
last_updated: "2026-11-14"
published: "2026-10-03"
author: "Kevin Vera"
---

# Cork vs Herdr: where agents live vs how they share a codebase

Cork vs Herdr: Herdr keeps AI coding agents running in persistent terminal panes. Cork keeps those parallel agents from overwriting each other's code.

By Kevin Vera · October 3, 2026 · [Comparisons](https://corkcli.com/blog/c/comparisons) · 7 min read

How is Cork different from Herdr? Herdr is a terminal runtime for coding agents: each agent gets a real terminal pane that keeps running after you detach, and a sidebar tells you which agents are working, blocked or idle. Cork is not a runtime at all; it is a [coordination layer](https://corkcli.com/blog/coordination-layer-ai-coding-agents) that keeps those agents, and the people running them, from overwriting each other on the same codebase. Herdr answers "where do my agents live and which one needs me?", Cork answers "what happens when two of them edit the same code?" The two fit together cleanly.

## Cork vs Herdr at a glance

| Topic | Cork | Herdr (as of October 2026) |
|---|---|---|
| What it is | A coordination layer for multiple AI coding agents on one codebase | A terminal multiplexer and runtime built for coding agents |
| Where agents run | Where they already run, on your machine | In Herdr panes, locally or on machines connected over SSH |
| Agents covered | Claude Code, Codex, Cursor (hooks), plus any MCP client | Detects 22 agents, including Claude Code, Codex, Cursor, opencode and Grok |
| What is shared | Live code changes, signatures, callers, notes anchored to code | Terminal sessions and agent state (working, blocked, idle) |
| Conflict handling | Write gate, live awareness, [semantic lint](https://corkcli.com/blog/semantic-lint), rebase-test-push landing | Not addressed in its docs; agents can prompt and wait on each other via the socket API |
| Install | `curl -fsSL https://corkcli.com/install.sh \| sh` | `curl -fsSL https://herdr.dev/install.sh \| sh` or `brew install herdr` |
| Open source | Cork Free runs locally with no account | Yes, Apache 2.0 |
| Pricing | Free (local, and 10 agent hours a month in the cloud); $20 a month per 100 agent hours, pooled | Free and open source; Herdr Cloud is on a waitlist |

## What is Herdr?

Herdr calls itself "the runtime your coding agents live on." It is a single Rust binary, a terminal multiplexer in the spirit of tmux, designed around AI coding agents. Per its website and GitHub README:

- **Persistent sessions.** Terminals keep running server-side after you close the client or lose SSH, and you can "come back from any machine" to find agents where you left them.
- **Agent state.** Herdr "reads every pane and marks each agent working, blocked or idle," so you can find the stuck one quickly.
- **Many machines.** Machines connected over SSH show their workspaces and agents alongside your local ones.
- **Agent-native control.** Through its CLI and socket API, agents can spawn panes, prompt each other and wait until another agent is blocked.
- **Plugins** for customizing workflows.

It detects 22 agents out of the box and does not wrap or replace them: it owns their terminals. Herdr is Apache 2.0, its site reports over a million installs, and a Herdr Cloud for connecting machines without configuring SSH is listed as coming soon.

## What is Cork?

Cork (corkcli.com, by Lithometric) keeps several AI coding agents, and the people running them, from overwriting each other on one codebase, and hands each agent what the others already learned. It does not run agents or host machines; Claude Code, Codex and Cursor keep running where they already run, and Cork coordinates them through hooks with no extra model calls, plus an MCP server any MCP client can use.

- **Briefing**: at start and on each prompt, an agent receives the exact signatures, callers and recent changes of the code it is about to touch.
- **Live awareness**: a teammate's rename or new signature reaches your agent on its next step.
- **[Write gate](https://corkcli.com/blog/write-gate)**: an edit against code another agent is changing right now is held until your agent has their version.
- **Semantic lint**: renames and signature changes become lint rules your agents are checked against.
- **Landing**: `git push` becomes one step that rebases onto teammates' commits, reruns the tests and pushes.
- **Agent messaging** and MCP tools such as `get_symbol`, `blast_radius`, `recap` and `remember`/`recall`.

## Where Herdr stands out

- **Agents that survive disconnects.** Close the lid or lose SSH and the work keeps going. Cork does not host or keep sessions alive.
- **At-a-glance state.** Working, blocked and idle markers across every pane make running many agents manageable.
- **Remote machines in one view.** Local and SSH machines sit side by side.
- **Free and open source**, with a tiny install and broad agent detection.
- **Agents driving agents.** The socket API lets one agent spawn and prompt another.

## Where Cork wins

- **The code itself.** Herdr shows you which agent is blocked; it does not know that two of them are editing the same function. Cork's write gate holds that edit until the second agent has the first one's version.
- **Context before editing.** Each agent starts with a briefing on the code it is about to touch, so it searches less.
- **Renames and signatures.** Semantic lint catches a parallel agent still calling the old name.
- **Across people, not just panes.** On Cork's paid plan, agents on teammates' machines see each other's live changes.
- **Measured savings.** In Cork's benchmark (12 Claude Code agents at once on one repository, hard tasks), agents with Cork used 53% fewer tokens than the same agents without it.

## Can you use both?

Yes, and this is one of the cleanest pairings. Herdr gives your multiple Claude Code agents (or Codex, or Cursor) a durable home and tells you which one needs attention. Cork's hooks run inside those same agents, so when three Herdr panes are working in one repository they get briefings, hear each other's changes and do not overwrite each other. Herdr manages the terminals; Cork manages the collisions.

## Pricing compared

**Cork:** Cork Free gives unlimited agents and repos on one machine, no account, with all data staying on the machine. Cloud Free (with an account) is 10 agent hours a month per account (30 bonus hours the first month), unlimited repos and agents, 30-day history. Beyond that you pay for agent hours, not seats: $20 a month per unit of 100 hours, pooled across the workspace, graduated to $17 (units 11 to 50) and $15 (51 and up), with 15% off a year. Every member is a player, with teammates' machines, prompts matched to code by meaning, shared knowledge and 90-day history. Enterprise starts from about 100 units.

**Herdr:** free and open source under Apache 2.0. Herdr Cloud is listed as coming soon with a waitlist, and we could not verify published pricing for it as of October 2026.

## Bottom line

Herdr is an excellent place for [parallel AI coding agents](https://corkcli.com/blog/parallel-ai-coding-agents) to run: persistent, observable and free. It does not try to coordinate what those agents do to shared code. Cork does only that, with no runtime of its own. If you run several agents in Herdr on one repository, Cork is the layer that stops them from colliding.

## Frequently asked questions

### Is Cork an alternative to Herdr?

No. Herdr is a terminal runtime and Cork is a coordination layer; neither replaces the other. Most people running many agents in Herdr on one repo would use both.

### Does Herdr stop agents from overwriting each other?

Not as far as its docs say as of October 2026. Herdr tracks each agent's state and lets agents prompt and wait on each other, but it does not inspect or gate code edits. Cork's write gate does.

### Can I run multiple Claude Code agents in Herdr with Cork?

Yes. Cork's hooks live inside Claude Code, so they work in any terminal, including Herdr panes.

### Is Herdr open source?

Yes, under the Apache 2.0 license.

### Does Cork keep agents running when I close my laptop?

No. Cork does not host agents or sessions. For that you want a runtime like Herdr, or a cloud agent service, alongside Cork.

## Sources

Checked October 2026:

- <https://herdr.dev>
- <https://github.com/ogulcancelik/herdr>
- <https://corkcli.com/benchmarks/study-5-twelve-agents-53-percent>

## Related reading

- [Cork vs Mosaic: shared session memory, or live coordination on the code](https://corkcli.com/blog/cork-vs-mosaic): Cork vs Mosaic: Mosaic syncs AI coding sessions into shared team memory; Cork keeps parallel agents from overwriting each other. How they differ and fit.
- [Cork vs Amika: VMs for your agents, or coordination between them](https://corkcli.com/blog/cork-vs-amika): Cork vs Amika: Amika provisions multiplayer VM Rigs for coding agents. Cork keeps parallel agents on one codebase from overwriting each other.
- [Cork vs Xirp: run many agents, or keep many agents from colliding](https://corkcli.com/blog/cork-vs-xirp): Cork vs Xirp: Spotify's Xirp runs parallel coding agent sessions in worktrees on macOS. Cork coordinates those agents so they stop overwriting each other.
- [Cork vs Warp: orchestrating agents in the cloud, or coordinating them on one codebase](https://corkcli.com/blog/cork-vs-warp): Cork vs Warp: Warp's Oz runs and orchestrates cloud coding agents at scale. Cork keeps parallel AI coding agents from overwriting each other's code.

[All articles](https://corkcli.com/blog.md) · [Cork in Markdown](https://corkcli.com/index.md) · [llms.txt](https://corkcli.com/llms.txt)

This page in HTML: https://corkcli.com/blog/cork-vs-herdr
