Backlog — the task orchestrator
for AI coding agents.
Run Claude Code, Codex, and your own CLIs across isolated git worktrees.
Claims, retries, review — all local by default.
Free and open-source. Desktop, CLI, SDK — no account required.
$ backlog init ✓ created .backlog/ with config + state files # Drop a task on the board, AI splits it into sub-tasks per repo. $ backlog task add "Refactor billing into its own service" --priority P1 ✓ task_001 queued ✓ AI proposed 3 sub-tasks across api / worker / web # Each sub-task takes an exclusive claim on its file scopes. $ backlog run → 2 sub-tasks running on isolated worktrees, 1 waiting on dependency # Same kanban in your browser (CLI) or in a native window (Desktop). $ backlog board → Backlog board listening at http://127.0.0.1:7878
Why teams pick Backlog
Six outcomes, the same reasons the CLI has been on npm since day one and the Desktop app shipped today.
Ship 3–5× faster on multi-file work
One feature usually spans an API, a worker, a web client. Backlog's AI splitter proposes the breakdown; sub-agents run in parallel; total time collapses to the longest path, not the sum. See how →
No merge nightmares
Claims lock the file scopes, worktrees isolate each run, the scheduler keeps the plan consistent every tick. Two agents can't trample each other — even crashed runs recover via TTL. See how →
Auditable by default
Every commit gets Backlog-Run / Task / Subtask trailers. Run inspector links every change back to the task that requested it, the claim that authorised it, and the agent that produced it. git log --grep=Backlog-Task:task_… just works.
Your code never leaves the box
Default mode is fully local. No telemetry, no signup, no cloud round-trip. Use your own Anthropic / OpenAI keys; the agent CLI runs on your machine, the orchestrator runs on your machine, the kanban runs on your machine. Cloud is opt-in.
Free forever for individuals
CLI + Desktop + SDK are Apache-2.0. No seat caps, no run caps, no feature gating. Cloud adds hosted backend / SMTP invites / SSO when you need them — the open-core boundary maps to infrastructure we run, not features we lock.
Bring your own agent
Claude Code, Codex, your custom shell command — Backlog dispatches whichever you've configured. Mix providers per task: cheap reviewer on Haiku, primary worker on Sonnet, Codex when you need GPT-5's reasoning. The orchestrator picks the best fit.
How it works
A small, opinionated loop. Local by default — no account, no telemetry.
Plan
Add a task on the board. AI splits it into sub-tasks scoped to specific repos and risk levels.
Claim
Each sub-task takes an exclusive claim on its file paths. The pre-commit hook refuses commits that aren't covered.
Run
The orchestrator dispatches sub-tasks to Claude Code, Codex, or your custom agent — each on an isolated git worktree.
Review & commit
Sub-task IDs land in commit subjects automatically. The Commits view links every change back to its task, sub-task, and claim.
Parallel by design — multiple sub-agents, one task
A feature isn't one job. It's usually a stack of sub-jobs across an API, a worker, a web client, sometimes docs and tests. Backlog's AI splitter looks at your description and proposes the most efficient breakdown — then dispatches each sub-task to its own sub-agent in parallel. Wall-clock time collapses to the critical path.
AI split: efficient by default
Type a one-line task, click Split. Claude proposes 2 to N sub-tasks scoped per repo, each with explicit file paths, a risk level, and a depends_on graph for the few cases where order actually matters. You can edit, drop, or accept the plan as-is.
Concrete: "Refactor billing into its own service" → 3 sub-tasks proposed: extract billing module (packages/api/billing/**), wire the worker job (packages/worker/**), update the web client (packages/web/**). All three independent — they run truly in parallel.
Sub-agents in parallel
Each sub-task is picked up by its own sub-agent — a Claude Code, Codex, or custom-CLI instance running in an isolated git worktree. Independent sub-tasks fan out simultaneously up to your configured fleet size; dependent ones queue and trigger as soon as their upstream completes.
Concrete: 3 independent sub-agents on 3 worktrees finish in ~10 minutes. The serial equivalent — one agent doing all three — takes ~30. The hard part isn't speed, it's that the parallel run is also safe (see below).
Critical path, not sum
When dependencies do exist, Backlog serialises only the chain that needs it. A → B blocks B until A is done; everything else runs concurrently. Total wall-clock = the longest path through the graph, not the sum of all sub-tasks. Watch the orchestrator panel: green = running, amber = waiting on a dep, grey = queued.
Concrete: 5 sub-tasks where 1 must run before the other 4. The 4 fan out in parallel after the first finishes. Total time = task 1 + max(2..5), not the sum of all 5.
The fleet size is yours to set: max_agents in config.toml or the slider in the orchestrator panel. Cap it at 1 and you get serial, predictable runs (good for a single OpenAI key with rate limits). Crank it to 8 and you get an army (good when each sub-agent costs you tokens but saves you minutes). Either way, the safety net underneath is the same — claims, worktrees, the scheduler — and it's what keeps the parallel run from turning into a merge nightmare.
No more agent collisions, no more race conditions
The instant you run more than one AI agent on the same codebase, three things go wrong: they overwrite each other's edits, they branch from inconsistent state, and you spend the afternoon untangling git instead of shipping. Backlog's three primitives — claims, worktrees, and the scheduler — make those problems impossible by construction.
Claims = file-scope locks
Before an agent starts, it takes an exclusive claim on the file paths its sub-task will touch (e.g. packages/billing/**). Another agent whose sub-task wants the same paths is held in the waiting column with a clear "scope conflict with claim X" reason — not silently launched into a merge fight.
Concrete: Agent A is fixing the billing bug on packages/billing/**. Agent B wants to add a billing feature on the same path. B simply doesn't start until A finishes — no branch surgery required.
Each run gets its own git worktree
Every run executes on a dedicated git worktree with its own branch (backlog/<task-id>). Two agents working on disjoint scopes run truly in parallel — different directories, different working states, no race for the index. Your main checkout is never touched.
Concrete: Agent A edits packages/api/**, agent B edits packages/web/**. Both run at the same time on separate worktrees. Neither sees the other's intermediate state. Both commit cleanly.
Scheduler keeps the picture consistent
Every tick, the scheduler rebuilds the execution plan from the current claim set, active runs, agent capacity, and your autonomy mode. Crashed runs leak their claim TTL after 30 minutes (heartbeats keep healthy ones alive). Failed sub-tasks cascade their dependents into blocked instead of letting them silently start with stale assumptions.
Concrete: Agent A crashes mid-run on the billing fix. Its worktree is intact, its claim's TTL expires, and the scheduler offers the same sub-task to the next available agent — picking up where A left off.
The pre-commit hook is the seatbelt. It refuses any commit whose changed paths aren't covered by an active claim — meaning you literally cannot push half-merged work from one agent's worktree onto another's branch by accident. Set auto_claim_on_commit = true in config.toml and the hook creates the claim from your staged paths instead of blocking, so the invariant holds even when you're typing into the terminal yourself.
One engine, three surfaces
Same orchestrator core, packaged for how you work. All three are open-source under Apache-2.0.
Backlog CLI
Headless, scriptable, the one you put in CI. init, task, claim, runs, worktree.
Backlog Desktop
Native kanban, run inspector, agent fleet. Same engine as the CLI, in a window. Zero terminal.
Download Desktop →Backlog SDK
Embed the orchestrator in your own tool. TypeScript-first, OpenAPI 3.0.3 spec, types generated from the contract.
Read the SDK docs →Pricing
CLI, Desktop, and SDK are free forever. Cloud is in private development — prices land at GA. See the breakdown →
- CLI + Desktop + SDK, all features
- Unlimited local repos & runs
- All connectors with BYO token
- No credit card · no signup · runs offline
- Hosted workspace sync, multi-machine
- SMTP invites, SSO, multi-user collab
- Hosted run executors (metered)
- Retention, audit export, SLA
Open-core, by design
The Desktop app, CLI, and SDK are all open-source under Apache-2.0. Run them locally with your own keys, or point them at Backlog Cloud when you want hosted infra. Either way, the contract is the same OpenAPI spec.
# Self-hosted? Point any client at your own backend over the same OpenAPI contract. $ export BACKLOG_CLOUD_URL=https://backlog.acme-corp.com $ backlog serve ✓ Backlog board listening at http://127.0.0.1:7878 ✓ OAuth proxy → backlog.acme-corp.com # Or just run the Desktop app — same engine, in a window. $ open /Applications/Backlog.app