Cerberus

Many Heads, One Plan

Now in Preview

A cross-platform desktop orchestrator that turns a plan into parallel Claude Code agents, each working its own task in its own worktree.

Parallel Agents

Multi-Repo Workspaces

Plans to Tasks

Isolated Worktrees

Cross-Platform

From Plan to Parallel

One workflow from the first idea to reviewed branches
1
Plan

Think the feature through with an agent in a markdown plan, across one repo or several.

2
Split

The plan breaks down into branch-sized tasks, with the order they have to land in.

3
Launch

Finalize the plan into a session and a pack of agents picks up the tasks in parallel.

4
Review

Every agent's work lands on its own branch, ready to review in a built-in diff view.

Run the Whole Pack

Running one agent is easy. Running five without them stepping on each other is not. Cerberus gives every agent its own git worktree and branch, and keeps all of them in view from one window.

Every agent isolated in its own worktree and branch

Watch every running agent side by side

Get notified the moment an agent needs you

Approve tool use before it runs

Session: login-rework
Extract token service cerberus/login-rework/extract-token-service
Running
Remove client refresh logic cerberus/login-rework/remove-client-refresh
Needs approval
Update sign-in copy cerberus/login-rework/update-sign-in-copy
In review
login-rework.md
# Login rework

Move token refresh out of the web client
and into the API so every app shares it.

### Task 1: Extract token service
**Repo:** api

### Task 2: Refresh tokens on 401
**Repo:** api
**Depends on:** Task 1

### Task 3: Remove client refresh logic
**Repo:** web

Plans Become Tasks

Planning then executing is how good agent work already happens. Cerberus makes it the product: a plan holds the reasoning for a feature, and each task it produces is sized to one branch, one agent and one review.

Plans and tasks are plain markdown you can edit

Plan alongside an agent, right next to the document

Generate every task from the plan in one step

Track every task on a kanban board

Smart Splitting

Not every task can start at once. Cerberus knows which tasks depend on which, runs the independent ones in parallel, and holds the rest until their prerequisites are done.

Dependencies declared right in the plan

Dependent tasks wait, and say what they are waiting on

Cycles and bad references caught before any task is created

Full status history for every task

Tasks: api
Task 1: Extract token service No prerequisites
Running
Task 2: Refresh tokens on 401 Waiting on Task 1
Waiting
Task 4: Rate limit token endpoint No prerequisites
Running
Starting session
✓ Plan finalized: login-rework
✓ Session created for api
✓ 2 tasks ready, 1 waiting
✓ Worktree: extract-token-service
✓ Worktree: rate-limit-token-endpoint
▶ 2 agents working

Jump-Start a Session

Finalize a plan and the work starts. No copying prompts between terminals, no setting up branches by hand. Cerberus creates the session and the worktrees, and puts agents on the tasks.

From finished plan to working agents in one step

Every agent starts with the plan's context

Choose how many agents run at once

Session active time tracked across every agent

Multi-Repo Workspaces

Real features rarely stay in one repo. Group your repos into a workspace, write one plan that spans them, and Cerberus writes each task into the repo it belongs to, with a session for each.

Several repos in one workspace

One plan across repos, one session per repo

Plans, tasks and worktrees kept outside your repos

Nothing to add to your .gitignore

Workspace: acme
api Session: login-rework
3 tasks
web Session: login-rework
1 task
shared-ui No active session
Idle

Built for Agent Work

Everything you need to keep a pack of agents on track
Kanban Board

Every task from backlog to review, at a glance

Agent Grid

Every running agent's conversation, side by side

Diff Review

Review each agent's changes, uncommitted edits included

Attention Alerts

Know when an agent is waiting on you

Markdown Plans

Edit plans and tasks as source or rendered markdown

Isolated Worktrees

One worktree and branch per task, managed for you

Claude Code Powered

Runs the Claude Code CLI you already use

Native Desktop

Built on Hermes for Windows, macOS and Linux

Download Cerberus

Preview builds for every platform
Windows

Windows 10 or later

Signed executable
macOS

macOS 12 or later

Signed & notarized
Linux

Ubuntu, Fedora, and more

AppImage package

Frequently Asked Questions

Everything you need to know about Cerberus
What is Cerberus?

Cerberus is a cross-platform desktop app for orchestrating coding agents. You plan a feature, Cerberus splits the plan into tasks, and a session of Claude Code agents works those tasks in parallel, each in its own git worktree, so their changes never collide.

Which agents does Cerberus run?

Cerberus runs Claude Code. You'll need the Claude Code CLI installed and signed in on your machine; Cerberus checks for it at startup and before any agent starts.

Will Cerberus change my repositories?

Cerberus keeps its plans, tasks and worktrees in its own data folder, never inside your repos. Each agent's commits land on its own branch in your repo, so you review and merge them like any other branch.

Can one plan cover several repositories?

Yes. A workspace holds several repos, and a plan can target any of them. Each task is written into the repo it belongs to, and finalizing the plan starts one session per repo.

What platforms does Cerberus support?

Cerberus is a native desktop application for Windows 10+, macOS 12+, and Linux, built with Hermes. Windows builds are signed and macOS builds are signed and notarized.

Is Cerberus free?

Cerberus is free during the preview. Pricing for the full release has not been announced yet. You pay for your own Claude Code usage as usual.

How stable is the preview?

Cerberus is in early preview and moving quickly. Expect rough edges and frequent updates, and expect your feedback to shape what comes next.

Ready to Unleash the Pack?

Download the Cerberus preview and take your next feature from plan to parallel agents.