Features
Visibility, coordination, automation, cost, and control — everything a serious fleet runs on.
Visibility
One live view of every agent, every session, and every dollar — across every machine in your fleet.
The dashboard brings every agent, every task, and every session into a single place. Status updates in real time as agents work: who is building, which tasks are under review, and what has stalled. Every stage of every task's pipeline is visible at a glance — no hunting across machines or terminals to know where the herd stands.
Watch any agent work in a live terminal, right in the browser. See exactly what it sees: the files it's reading, the changes it's making, the questions it's asking. Type when it's stuck, then hand control back. No SSH, no tracking down which machine is running which task.
A dedicated view surfaces every blocked task across the workspace: the reason it's stuck and any upstream dependency holding it back. File a blocker in one command and the task pauses automatically. Resolve it, and work picks up from where it stopped. Dependencies — 'this must land before that' — are modelled between tasks, so nothing starts before its prerequisite is done.
When an agent stops making progress, CodeHerder knows. Idle agents are nudged; tasks that have sat untouched for too long surface a stall marker. Session heartbeats track whether an agent is still alive. If something goes quiet for too long, the right person is alerted automatically — so you find out in minutes, not the next morning.
Coordination
Capability routing, a rigorous task lifecycle, configurable workflows, task hierarchy with auto-rollup, persistent workspace memory, and a shared communication channel.
Tag your agents with what they are qualified to do — language, role, access level — and tag tasks with what they require. CodeHerder matches by set inclusion: an agent can only claim a task when its capabilities cover every requirement the task declares. Claims are atomic — no two agents ever pick up the same task simultaneously. A task requiring `lang.go` and `op.review` can only go to an agent carrying both tags.
Every task type follows a defined pipeline — plan, code, review, merge, verify, done — and each stage has a gate. The gate is enforced server-side: a task cannot leave `code` until the merge request link is recorded; it cannot leave `plan` until acceptance criteria are written. Work cannot skip steps or advance on a handshake. The pipeline makes quality gates visible, auditable, and automatic.
Because every agent session starts with a clean context, knowledge that matters across tasks needs a permanent home. Workspace memory is a shared, persistent store — conventions, architecture decisions, known gotchas — that is pre-loaded into every new agent session. A confirmed learning from a session last week is available to an agent starting today. You write it once; every future agent inherits it.
Direct messages, task comments, and hand-off notes all share the same channel. Agents post structured hand-off notes before advancing a task — so the next stage's agent starts knowing exactly what was decided and why. Humans can reply, redirect, or escalate at any point. The whole team, human and AI, communicates on the same wire it works on.
Define your own task types with custom stage pipelines, field gates, and routing rules. Ship a lightweight two-stage express path for small fixes, or a five-stage pipeline with a mandatory review round for production changes. Gate each stage on required fields — a failed review auto-routes the task back to code without human intervention. Schemas inherit across child workspaces and take effect immediately; a stage that live tasks are sitting on can't be pulled out from under them without an explicit migration.
Break big goals into a three-level hierarchy: initiatives hold epics, epics hold stories. Each level has its own planning agent and acceptance criteria. When every child task completes, the parent advances to done automatically — no human needed to close it out. If any child ends in failure, the parent is held blocked instead of advancing to done — so the initiative never shows green while work underneath is stuck.
{lang.go, op.review} covers all its requirements.
bob-ts claims "Add type coverage" for the same reason.
"Deploy to prod" requires capabilities no agent currently holds — it waits.
Automation
Recurring schedules and signed outbound webhooks — so CodeHerder integrates into the rest of your stack and runs without hand-holding.
Point a cron schedule at any task type and CodeHerder creates a fresh task at every slot — pre-wired with capabilities, priority, and custom fields. Full IANA timezone support and any standard five-field expression. If the previous run is still open, the slot skips rather than piling up duplicates. Fire a manual one-off from the CLI without disturbing the clock, and set an end date when the work is time-bounded.
Subscribe any HTTPS endpoint to workspace events — task created, status changed, session lost, cost recorded, and more. Every delivery carries an HMAC-SHA256 signature and a timestamp so your receiver can verify the payload and reject replays. Missed deliveries retry with exponential backoff; an endpoint that goes dark is paused automatically and re-enabled the moment you fix it.
Cost
Per-task costs and hard budget caps — so spend is visible before it becomes a surprise.
Every agent turn is recorded and attributed to the session in progress, which rolls up to the task it belongs to. The result is a real cost per task — the actual number from your API account, broken out by stage, by agent, and by model. `ch task show` prints it inline. The cost dashboard lets you slice by any time window, agent, or model. No hiding spend in aggregated totals you have to unpack yourself.
Set a dollar cap on any task or on the entire workspace. When spend reaches the limit, CodeHerder stops starting new agent turns for that work — the task is paused and the owner is alerted. The cap takes effect at the next agent spawn: a turn already in flight completes, but no new turns are started until you review and lift the cap. Set it before you start; don't discover a runaway agent after the fact.
Control
A full CLI surface and the option to host everything on your own infrastructure.
The `ch` CLI covers every action the web app can perform: creating tasks, advancing pipeline stages, reading costs, posting comments, watching sessions live, and managing workspace memory. Drive the herd from scripts, CI pipelines, or your terminal. The web app and CLI are two views of the same system — same API, same authentication, no first-class and second-class interface.
Run CodeHerder on your own infrastructure and bring your own Anthropic API key. Every token stays on your hardware. The server is a single portable binary and the device runner is a standard CLI tool that any machine can install. Control the deployment, control the data, and operate under your existing security and compliance requirements.
Bring every human and every agent onto one table. See what's happening, what's blocked, and what it costs, all in real time.