Kanban for coding agents · the execution layer

The board where your coding agents actually do the work.

Drag a ticket to Start and Cordane cuts a git worktree, boots your dev server on its own URL, and turns Claude Code loose — while your whole team watches from any browser. Keep your tracker; this is where the code gets written, watched, and approved.

one board · agents running on machines you own · live for the whole team
acme.cordane.app

Backlog 2

PROJ-71
Add CSV export to reports
PROJ-73
Rate-limit the webhook endpoint

Planning 1

PROJ-68
Refactor auth middleware
agent planning · worktree ready

In progress 2

PROJ-42
Add rate limiting to login
implementing · :5183
$ go test ./...  →  ok
PROJ-70
Fix flaky checkout test
implementing · :5193

In review 1

PROJ-65
Dark-mode toggle
+142 −18 · 6 files · checks ✓
See it

A ticket, a worktree, a real agent run.

Plan starts the work — worktree, branch, space — and hands the agent the ticket inside that worktree. What you see is whatever Claude Code actually produced on the day it was filmed, not a rehearsal.

A kanban ticket driving a Claude Code run in its own git worktree
Watch · 3:36
Nothing loads from YouTube until you press play. Open on YouTube · all 33 walkthroughs
What the board does

A card isn't a task to assign. It's a run to supervise.

01

Drag it, and it starts itself

Move a ticket to Start and Cordane cuts a git worktree, boots your dev server on its own URL, and turns Claude Code loose — while your whole team watches from any browser.

02

Ten agents, zero collisions

Run ten agents in parallel, on machines you own — every ticket gets its own branch, ports, and live preview. Nothing collides, nothing's exposed, and one page tells you which of the ten is waiting on you.

03

A diff, not a mystery commit

Review a diff and a green-checks badge, not a mystery commit. Keep Linear for the roadmap — Cordane is where the code gets written, watched, and approved.

The lifecycle

Ticket → worktree → agent → review → PR.

This is the whole loop. Every stage happens on a machine you own, and every teammate can watch it as it goes.

PROJ-42 Add rate limiting to the login endpoint backlog

It starts as a card.

A ticket is a title and a description on a board your whole team shares. Nothing is provisioned yet — no branch, no machine, no cost. Drop it into Start when you're ready to run it.

board · shared with your team workers · private to each member
board
backlog ┌───────────────────────────┐ │ PROJ-42 Add rate limiting │ │ to the login endpoint │ └───────────────────────────┘ waiting to start…

Start → it provisions everything.

Cordane cuts a git worktree from the latest main, reserves a unique block of ports, opens a workspace of terminals, and boots your dev server on its own preview URL. No local checkout, no port juggling.

branch · proj-42-rate-limit preview · proj-42--vps.cordane.app ports · 5183, 5184 reserved
provision
✓ worktree ready · branch proj-42-rate-limit ✓ ports 5183–5184 reserved ✓ dev server up · preview live ✓ agent pane opened

The agent plans, then writes the code.

Claude Code writes an implementation plan back to the ticket. Approve it and the agent implements in the worktree — running your project's real toolchain — and commits on the ticket branch. Your whole team can watch the terminal live.

commits · on the ticket branch sandbox · optional Docker image
agent · implement
edit middleware/ratelimit.go +64 edit middleware/ratelimit_test.go +38 run go test ./... ok all tests passed commit proj-42: rate-limit login

You review a diff, not a mystery.

The card lands in review with the exact prompt the agent ran, a unified diff, the commit log, and a check-hook badge. A behind-main indicator shows drift and which files overlap your other open tickets, so nothing surprises you at merge time. Not right yet? Pin notes to lines of the diff and send it back — the agent takes another pass on the same branch.

check hooks · passed behind main · 0 commits
changes · PROJ-42
diff middleware/ratelimit.go + if !bucket.Allow(ip) { + w.Header().Set("Retry-After", "60") + http.Error(w, "slow down", 429) + } ● checks passed · 2 commits

Approve → push and open a PR.

When it's good, Cordane pushes the branch and opens a PR in the background. Cleanup tears the worktree down and returns the ports; the next ticket reuses a warm cache and starts in seconds. Your tracker never had to know how the sausage got made.

push + PR · background, non-blocking cleanup · ports returned, cache kept
done
✓ pushed proj-42-rate-limit ✓ opened PR #128 ✓ ports released · cache kept ● done
Why not just Jira?

Because a tracker and this are different categories.

A tracker hands a ticket to a human and waits. Cordane hands a ticket to an agent and runs it — cutting the worktree, booting the preview, and streaming the terminal to your team as it goes. One organizes intent; the other executes it. Comparing them feature-for-feature misses the point, so we won't put up a parity matrix that pretends they're the same thing.

So keep your tracker — Cordane is the execution layer where agent work happens. Linear or Jira stays the source of truth for the roadmap, the sprints, the stakeholders. Cordane is the surface where a card becomes a running agent on a machine you own, at a URL your whole team can open.

“In the agentic world, the real work is keeping an eye on tickets and workers. Supervision is the job. The enemy isn't Jira — it's the eight terminal tabs nobody else can see.”

— the founder, on why the board exists
The receipts

Every ticket keeps a full audit trail.

When an agent writes the code, you want to know exactly what it was told, exactly what it changed, and who signed off. Cordane keeps all of it, per ticket — nobody else in the category does.

The exact prompt

The precise instruction the agent was given for this ticket is kept with the card — no guessing what it was actually asked to do.

The exact diff

A unified diff and the commit log for the change, right on the card — you review what shipped, not a summary of it.

Who approved, what checks ran

The person who approved the plan and the merge, plus the check hooks that ran and passed — compliance-ready, without extra tooling.

Yours to walk with

It's all in a plain SQLite database you can export any time. No lock-in on the record of what your agents did.

Straight talk

Not your company's PM tool.

We'd rather tell you what this board isn't than watch you try to move your whole team onto it and bounce. Here's the honest shape of it.

  • No sprints, epics, or project reporting. There are no burndown charts, velocity, or roadmap views — the only numbers are about agent runs (cost, time, outcomes). This is a board for supervising agent runs, not planning quarters.
  • Not where a PM or designer lives. The columns are about work an agent is running, not a home for every stakeholder's tasks. Keep Linear or Jira for that.
  • It's the execution layer, not a replacement. Keep the tracker you already have as the source of truth; bring the tickets worth running to Cordane and run them here.
  • Sentry, Jira, GitHub Issues and Linear in. Paste an issue URL to import it as a ticket, attachments included, or let a connection poll a filter — a Sentry search, a JQL, a GitHub repo’s labels, a Linear team — and create tickets as issues arrive. When the ticket reaches Done, Cordane can close the upstream issue.
FAQ

The questions engineering leads ask.

Does Cordane replace Jira or Linear?
No — keep your tracker. Cordane is the execution layer where agent work happens, not your company's project-management tool. It has no sprints, epics, roadmaps, or project reporting, and it isn't where a PM or designer will live. Linear or Jira stays the source of truth for planning; Cordane is where a ticket turns into a running agent, a diff, and a PR.
What actually happens when I drag a ticket to Start?
Cordane cuts a fresh git worktree branched from your latest main, reserves a unique block of ports, opens a workspace of terminals, and boots your dev server on its own preview URL. Then it turns your coding agent loose to plan; you approve the plan, and it implements in the worktree and commits on the ticket branch — while your whole team watches from any browser.
Can I run several agents at once?
Yes — that's the point. Run ten tickets in parallel on machines you own, and each gets its own branch, its own ports, and its own live preview. Nothing collides, because every ticket is an isolated worktree; nothing is exposed, because the workers dial out.
With ten agents running, how do I know which one is stuck?
Every agent pane reports its state, and the Agents page groups them across every space and every worker: waiting on you at the top (stopped on a permission prompt or a question — nothing moves until someone answers), then done (finished a turn since you last looked), then working and idle. Each row opens the exact pane, and the board cards carry the same state rolled up, so a stuck agent shows on the card without opening it. Turn on alerts and the person whose agent it is also hears about it — in the browser, through a webhook (ntfy, Slack, Discord) or by email. See how it reads.
What do I review at the end?
A diff and a green-checks badge, not a mystery commit. Each ticket carries a full audit trail: the exact prompt the agent was given, the exact diff it produced, who approved it, and what checks and hooks ran. Anything the agent left for you in .cordane/outputs/ — a screenshot of the feature, a benchmark, a generated report — is attached to the ticket when its run ends, so the evidence is on the card too. You review the change and the evidence, then merge, push, or open a PR — or request changes: write what to fix, pin notes to lines of the diff, and the agent gets another pass on the same branch, in its space or in the background. A project can also send failing checks back to the agent on its own, up to a retry budget you set.
Is my code exposed while an agent runs?
No. Agents, source, and secrets run only on the workers you own — even in managed cloud, where we host just the control plane. Workers dial out over one connection, so there's nothing inbound to open, and app previews are authenticated and team-scoped by default.
Can our PM or designer use this as their board?
It isn't built for that. There are no assignees-heavy workflows, priorities, labels, sprints, or project reporting — the board is deliberately about supervising agent runs, not tracking a whole company's roadmap. Keep Linear or Jira for the people work; use Cordane for the agent work.
Get started

Run your agents from a board.

Self-hosting is free and available now — start with the quickstart, no email required. Want us to run the hub? Managed cloud starts with a 14-day free trial from the pricing page; your workers stay on your machines.

Community tier: free forever, no license key, no account with us.