Four agents. One board. Zero collisions.

Parallel development only pays off when the work stays coherent. Give every run a bounded task, its own worktree, a visible state and one review path back to you.

Choose your download

Watch it work

Isolated worktree per run
Queue you can see
Spec-driven subtasks

1 → 16: concurrent runs by plan
1:1: run to isolated worktree
100%: of diffs reviewed by a human

PARALLEL, LIVE

Three agents working at once, and you can still follow it.

Tasks fan out to different agents, each run reports live, and an approved plan can become ordered subtasks that execute in sequence.

01 / 05

Give agents a real brief.

Create tasks with descriptions, acceptance criteria, images and tags—then move them through the workflow your team already understands.

Custom sections and columns
Agent, tag and role routing
Context stays attached to the task

PaymentsAcme workspace

Search tasks, agents, tags…⌘K

New task LR

Payments

Offline · 2 repositories

Filter by title, code or description… Type: all Priority: all Agent: all

Backlog

Manual

Add invoice export

TP-171 Medium

frontend

No agent

Migrate webhook retries

TP-168 Low

backend

No agent

In progress

Claude Code, Codex

Harden command approvals

TP-142 Urgent

securitybackend

COCodex

Refactor billing service

TP-151 High

backend

CCClaude Code

Needs input

Manual

Choose retry policy

TP-166 High

backend

CCClaude Code

Review

Codex

Add repository tests

TP-158 Medium

tests

GRGrok

Improve empty states

TP-163 Low

frontend

OCIn queue

Queue #2

CodexClaude CodeGrokOpenCodeOpenAI-compatible

Parallel execution needs shared structure

Opening more agent sessions is easy. Keeping their work coherent is the hard part. Without shared structure, two agents touch the same files, one waits on a question nobody read, and a third finishes changes that sit unreviewed for a day.

cadre.rocks organizes parallel development around the board. Ownership, progress, blockers and review live in one place, while each agent keeps using its own CLI, login and model. Isolated branches and worktrees make concurrency safe instead of hopeful.

HOW PARALLEL STAYS SANE

Bounded assignments

Each run is attached to one task with a description, acceptance criteria and repository — not a free-floating prompt.

Acceptance criteria tracked on the card
Task types, tags and swimlane sections
Context images passed to the agent

Isolation by construction

Concurrency is safe because runs never share a working directory or a branch.

One branch and worktree per run
Chained worktrees for ordered subtasks
Merge only into the branch you have open, on your command

Plans that become a backlog

Turn on spec-driven subtasks and an approved plan decomposes into sequential micro-tasks under an umbrella card.

Subtasks inherit repository and tags
They run in order, gated by the previous one
The umbrella tracks progress across the whole plan

HOW IT RUNS

From a defined task to an approved result.

01
Break the outcome into tasks
Separate work by responsibility so parallel runs have clear boundaries from the start.
02
Match tasks to agents
Choose the CLI, model and reasoning level per column, or bind agents to tags.
03
Resolve blockers centrally
Answer agent questions on the card, with the run and its logs still in front of you.
04
Merge through review
Inspect the plan and the diff, approve, and merge locally when the branch is ready.

Agents execute.
You keep the gates.

Questions, plans, commands and code changes return to one decision surface before the workflow can continue.

Choose your download

?Needs input

Question 1 of 2

How should board-wide approvals expire?

When the board closesAfter 24 hours Recommended

✦Plan ready for review

Claude Code · just now

Implementation plan

1. Validate repository paths at the service boundary.

2. Refactor the import coordinator and add adversarial tests.

✓Review changes

4 files · +128 −34

✓ command_policy.rs +64 −12 approval_service.rs +41 −18 command_policy.test.rs +23 −4

COMMON QUESTIONS

Questions, answered.

How do coding agents avoid editing the same files?

Every run executes in its own Git worktree on its own branch, so two agents never write to the same working directory. Bounded tasks and visible ownership on the board keep the work from overlapping in the first place.

Do all tasks have to use the same model?

No. Each column picks its own agents, models and reasoning effort, and tag-based routing can override the default per task.

What happens when I hit my concurrency limit?

Extra runs enter a visible queue with a position on the card and start automatically as slots free up. Free allows 1 concurrent run, Pro 4 and Team 16.

Can one plan produce several tasks?

Yes. With spec-driven subtasks enabled, approving a plan creates ordered subtasks under an umbrella task that inherit the repository and tags and run in sequence.

KEEP READING