Case study
Cat Herder
Parallel agents, binding reviews, and a board to watch them.
- Role
- Author
- Period
- Sep 2026–present
- Status
- Invite-only alpha
What Cat Herder does
Cat Herder lets many coding agents work one repo in parallel, in Claude Code, Codex, Cursor and more, with the option of a binding review before each change merges.
The queue is a branch in your repo, with no server. The first write to land wins each item, and the work lasts from one session to the next.
One orchestrator session scales the work out to worker and reviewer pairs on your machine, on other machines over ssh, or in cloud sessions. It watches for stalls, merges accepted work into release branches and hands work to a fresh session when one runs out of context.
Perch, an optional Kanban board in the browser, shows the whole queue as it moves.
I built it first for Life Automation, a private project of mine, once that work had spread across many agent sessions. Cat Herder shows whether every loose end has been captured, who is working on what, and where each piece stands on the path from an idea to finished work.
An agent can capture new work in the middle of a conversation, at the level the conversation already supports, then return to its task.
Cat Herder runs natively in Claude Code, Codex, Cursor, OpenCode, and Google Antigravity, though cross-provider operation is newer and less tested than the queue.
A queue in Git, not another service
Each item is a Markdown file with a small front matter block. It can begin as an idea and gain enough detail for another agent to start cold. Then one worker can claim it, send it through review, and finish it with a record of what happened. The queue lives on a Git ref or remote, separate from the code branch.
That choice came from Life Automation, which is private and locally hosted in my home lab. I did not want its planning state to depend on a third-party project-management service, and I needed more than a plain to-do list to represent the multi-step workflow around building, reviewing, and releasing work.
Git supplies durable history, optional synchronization between machines, and compare-and-swap writes. When two agents try to claim the same item, one fast-forward wins and the other is told that the state moved. Cat Herder writes queue state without switching the repository’s branch or touching partially edited working files.

The queue uses Git’s refusal to overwrite newer state as its lock. The losing agent reads again instead of forcing its write.
Capture the interruption, then return to the work
I kept the most important interaction small. When new work appears in the middle of a conversation, the agent captures it at the level the conversation already supports: an idea, a scoped item, or a ready brief. It asks only what is still needed, confirms in one line, and returns to the task that was already underway.

Capture is meant to preserve the tangent without letting the tangent take over.
The queue adds the workflow a list lacks: one session can claim a ready item, and a separate reviewer can send it back or accept it. Several items can be worked in dependency order, and the record remains after a conversation compacts, ends, or moves to another machine.
For a new user, the first thing that helps is rescuing an existing session. Cat Herder turns the work already discussed there into records, each with a next action, even when that action is to refine an incomplete idea. The goal is a credible sense that the loose ends have been surfaced and given somewhere to go, though capture makes no promise that nothing can ever be missed.
A worker and reviewer around the queue
A worker and reviewer are separate sessions. The reviewer starts without the worker’s conversation and can accept a change or send it back. The worker can dispute a finding, but the pair’s verdict is the reviewer’s to give. Cat Herder checks the accepting session’s recorded identity against the item’s reviewer; the human owner keeps an override. Depending on the item, the binding review can instead come from a reviewer started cold on just that item, a swarm of small agents described below, or the owner.
A “hike” has the worker take items in dependency order and send them through review. By default, the next item can start while the previous one is in review; the run can also wait for each verdict. New work can enter the queue while that happens. Capturing an interruption and doing a task use the same records, so an idea raised in one session can become another session’s next task.
The worker and reviewer can use different providers. Cat Herder has launcher adapters for that, including a durable Codex reviewer. It records the capabilities its launcher declares, such as repository access, queue writes and test dependencies, and leaves unknown capabilities explicit. Those are the launcher’s own declarations, with no independent check that each capability works, and a package for a platform is no proof that every one of them works there.
One orchestrator for many pairs
In a herd, the orchestrator is a session of its own, and each worker has a reviewer. meow herd scale reads the queue and the pairs and recommends one change at a time, but never starts or stops a session itself. When the owner says yes, the orchestrator starts the new worker or reviewer through a launcher, which puts it on the same machine, in a cloud session on claude.ai/code, or in tmux on a second computer over ssh through remote-session, a separate plugin.
Every 15 minutes a sweep checks the herd for stalls, such as an item in review with no live reviewer, a claim with no push for over an hour, or an accepted item that is not yet on its release’s integration branch. The sweep is code that finds the stalls, and the orchestrator, an agent session, follows role text that tells it to act on each one in that pass, for example by merging the accepted item.
A plugin hook counts each automatic compaction, when the host shortens a long conversation to make room; Antigravity has no such event, so nothing is counted there. At three, the default, the roster marks the session due to retire, and it hands off to a fresh session between items. The successor picks up from the queue, the item’s history and the handoff notes.
Perch, the board
Perch is an optional board in the browser, with releases down the left, a column for each state an item can be in, and a status line. Running meow perch starts it, and it writes to the queue only if you start it with --writes. It reads the same feed as the command-line status board and answers only on the machine it runs on, unless you put your own proxy in front of it. Cowork and cloud sessions can’t run it, since they have no long-running local process or browser on your machine.
Cold reads and kitten swarms
A cold read checks the task before the worker builds it. A fresh reader looks for gaps and unclear requirements, and the planner records the findings on the item. A queue can require a recorded cold read before an item is marked ready. The guard compares the read with recent changes to the task; it cannot tell whether the reader’s judgment was sound. It allows exemptions for some cases and an explicit, recorded way to skip it.
A kitten swarm checks a proposed change from several angles. Three or four small read-only agents look at correctness, tests, documentation or trust boundaries. Each gets the task and diff, without the worker’s notes or an earlier swarm’s findings. They report; the worker records what it took or rejected and why.
For build work, the paired reviewer reads that record before giving its verdict, including the findings the worker rejected. The kittens use Haiku 5.5. For lighter work, a fresh second swarm can provide the acceptance record when no high-severity finding remains unanswered. The paired reviewer and the swarm are separate review paths; having both does not mean every task needs the same amount of review.
Findings from running the loop
Several agents editing one repository meet the same problems people do, and Git has answers for most of them: each Cat Herder session works in its own Git worktree and on its own branch, made from the project’s one base clone. meow is Cat Herder’s command-line tool. A worker pushes the branch for the item it holds, and an accepted item merges into the release’s integration branch. Three things broke, and each now has a fix:
- Worktrees share one
.git/config. A per-session setting, such as a signing key, written there applied to every worktree of the repo. The fix turns on Git’s per-worktree config and reads a worktree’s own setting first. - Cleanup could not see the worktrees.
meow herd cleanremoves a finished session’s worktree and keeps the branch. It keeps any worktree that is locked, has uncommitted edits or a stash, or holds a commit not on the remote. Once, run from the project’s main clone, it could not see the herd’s worktrees, which belong to a second checkout, so the commands that manage the herd now run from that checkout. - Merging at the freeze. Accepted items waited for a batch merge, and an item could be merged forward again each time the integration tip moved. The orchestrator’s role text now has it merge each accepted item within 30 minutes, merge it forward once at hand-in, and never rebase a pushed branch.
Every test run goes through a slot that caps the CPUs parallel runs take on each machine, and runs in the background. meow herd test start places a run on the first listed host with room. The worker runs the mutation tests, and the reviewer cites the worker’s receipt.
The review record is more specific now: a worker cannot hand in a build bug fix without naming a run that shows the new test failing on the unfixed base. Passing tests on the new code alone do not show that the test detects the original defect. The command checks for that evidence in the hand-in; the reviewer still has to assess it.
Coordination also has a cost, which the status board cut by sharing a batch of answers instead of asking git separately about every accepted item. The recorded live-queue rebuild fell from 42 seconds and 1,076 git calls to 11 seconds and 323 calls. That figure covers one board operation on one queue and says nothing about the throughput of the development process.
Hand-in also reports overlap: which other pushed branches in the release change the same files, which sections they changed, and advice to build on a branch, refactor first or keep the change additive. That information arrives before integration, while the worker can still act on it, but it does not replace planning the work so that agents rarely edit the same paths.
What has been tested so far
Cat Herder’s own development has run through its queue since its first weekend. I also use its queue behind neckbeard, Life Automation, this portfolio, and the other active projects where work moves between sessions. That is internal dogfooding, which has forced the system to handle a large and changing backlog while it evolves but is no evidence of broad adoption.
The underlying queue is the most hardened layer: its black-box tests force compare-and-swap collisions against both local refs and a bare Git remote, including eight independent clones writing concurrently while each push is delayed by two seconds. They check that competing claims produce one winner and that unrelated writes all survive. They also check that retries recover from lost races and that the repository’s working tree and current branch stay unchanged.
Separate AI-agent sessions usually do the reviews and audits, while I make product decisions and step in as the human owner. The examples above come from running that process on my own projects. I have not yet run the larger retrospective that would show what it costs and which effects persist across different kinds of work.
There has been one early external installation in a Claude Code Project. Worker threads could reach the queue, but bootstrapping was flaky and I paused wider testing of that path. That experience is evidence about where the alpha is rough, and I do not offer it as a customer success story.
Where the alpha stands
Updated 2026-11-10 against v0.57.0.1, tagged 2026-11-10. What works most reliably today is several agents sharing a queue, especially on one machine. Cat Herder also has packages for Claude Code, Codex, Cursor, OpenCode, and Google Antigravity, plus launchers for cloud sessions and other computers, a broader direction I call In 3D.

Cat Herder in 3D: coordinating agents across providers, machines, and queues.
Claude can also delegate one-shot work to Codex through the CLI, a path Cat Herder already uses extensively.
Cowork has an early package with limited real-world testing. Cross-provider and multi-host operation are important differentiators, but they are also newer and less tested than the queue beneath them.
The repository remains private while I work through the gaps in those newer paths. I am inviting a small group of hiring managers and developers with a real workflow to test. Support is best effort, with no service guarantee.
Read the write-up: moving its tests and CI onto my own machines.
Request a private invite
If you are evaluating my work or have a workflow to try, request access through the contact page. Include your GitHub handle, the agent platform you intend to use, and what you would like to try; the first group stays small while the repository is private.