Running one AI coding agent in a chat window is easy. Running five at once is chaos. Which agent changed which file, which task is actually tested, and which half-finished edit is sitting in your working tree? Routa answers that chaos with an old, proven idea: a board. It is a workspace-first, open source platform that turns AI coding work into Kanban cards, with multiple agents working in separate git worktrees, every task carrying its evidence, and a review gate standing between work and Done.
Key Takeaways
Routa replaces scattered AI chat threads with a Kanban board where goals, tasks, sessions, traces, and review state stay visible.
Multiple agents run in parallel in separate git worktrees, so their edits do not collide in one working tree.
Cards move through strict lanes, Backlog, Todo, Dev, Review, and Done, plus Blocked, each with its own specialist role.
Nothing reaches Done without evidence and an APPROVED review verdict; dirty git state, missing evidence, and broken checks send work back.
It is open source under the MIT license, with 1,831 GitHub stars and 247 forks as of October 29, 2026, and it runs as a web app or a local-first desktop app.
Watch the 30-second repo signal: Watch the 30-second repo signal.
The problem: chat threads do not scale
A single agent session works well for a single task. The moment you run several agents in parallel, the chat model breaks down. Context lives inside separate threads, progress is invisible unless you ask, and two agents can happily edit the same file in different directions. The result is the classic multi-agent failure: lots of output, little confidence about what actually shipped.
Routa's answer, stated in its own README, is to keep goals, tasks, sessions, traces, evidence, and review state visible on a board instead of burying them inside a single chat thread. The board is not decoration. It is the coordination mechanism. If a card is in Review, you can see its evidence. If a card is Blocked, you can see why. If an agent is running, you can see its trace.
The project lives at phodal/routa on GitHub, and its own description calls it a "workspace-first multi-agent coordination platform for AI development, with shared Specs, Kanban orchestration, and MCP/ACP/A2A support across web and desktop." That description is worth unpacking, because each phrase names a design choice.
Workspace first, not chat first
In Routa, the workspace is the top-level boundary. Sessions, tasks, notes, boards, codebases, worktrees, and memories all belong to a workspace, according to the project's architecture documentation. That matters because it gives parallel work a shared home without forcing it into one thread or one branch.
From a workspace you get Kanban boards, session views, team views, and codebase views. You can import a GitHub repository as a virtual workspace, and you can work from the web app or from the desktop app. The desktop version is a Tauri shell backed by a Rust server, while the web version uses Next.js, but both preserve the same workspace, session, task, trace, codebase, worktree, and review semantics, as defined by the project's API contract. In plain terms: switching between web and desktop does not change how your work is organized.
Routa also coordinates other agents rather than including its own model, a point noted by Better Stack. Provider runtimes are normalized through adapters, so different agent tools plug into the same board through protocols including ACP, MCP, and A2A. The architecture documentation names Claude Code style streaming flows and Docker-backed OpenCode execution paths, but the README does not publish an exhaustive supported-agent roster, so treat the adapter model, not a fixed list, as the promise.
How a card moves: lanes with teeth
Routa's board has six lanes, and each lane is stricter than the one before it. This is where the tool stops being a pretty task board and starts being a delivery pipeline.
Aspect | Detail |
|---|---|
Backlog | A Refiner turns a rough idea into a structured task card |
Todo | An Orchestrator plans the work and delegates it in waves |
Dev | A Crafter implements the task, staying inside its scope |
Review | A Guard checks every acceptance criterion against the evidence |
Done | Only cards with an APPROVED verdict land here |
Blocked | A Resolver routes stuck cards back to the right lane |
Three roles do the heavy lifting. ROUTA, the coordinator, plans first, never edits files directly, writes the spec, waits for approval, and delegates work in waves. CRAFTER, the implementor, stays within task scope and avoids refactors and scope creep. GATE, the verifier, runs after implementation and decides whether the card can move.
The lane contracts are deliberately strict. Dev may move to Review only after a commit exists and the worktree is clean. Review moves to Done only with an APPROVED verdict. That sounds bureaucratic, but it is the whole point: in a multi-agent setup, the gate is what stops a confident-sounding agent from shipping untested work while you were looking at another card.
Worktrees keep parallel agents from colliding
The technical trick that makes parallel agents safe is git worktrees. A worktree is a separate working copy of a repository, checked out at its own branch, so several agents can each work on their own copy without stepping on each other. Routa's architecture documentation describes worktrees as ephemeral or semi-persistent execution copies tied to a workspace and codebase, and its desktop mode favors local agent binaries, local worktrees, and trace files.
That local-first flavor matters. The desktop app can run agents locally, keep traces on your machine, and use Docker-assisted execution where needed. The web mode offers the same board for self-hosted setups. Either way, the unit of work is a card backed by its own worktree, not a chat message that happened to edit a file.
The review gate: three layers of "prove it"
Routa's review is not a single thumbs-up. It is a stacked decision path with three parts, and each part answers a different question.
Harness Monitor: what happened? It surfaces traces, changed files, commands, git state, and attribution, so the reviewer sees the actual run, not a summary of it.
Entrix Fitness: does it meet the hard rules? It applies evidence requirements, file budget checks, and policy checks, the non-negotiable constraints.
Gate Specialist: can this card move? It decides whether the card goes to Done, back to Dev, or up to a human for escalation.
The Review Guard independently checks every acceptance criterion and rejects missing evidence, scope creep, dirty git state, or broken lint and type checks. That combination is what Geeky Gadgets calls automated quality gates, and it is the feature that separates Routa from a generic Kanban tool with an AI label stuck on it. A card accumulates an evidence bundle as it moves, including code diffs, test results, command outputs, and decision logs, according to Better Stack. By the time a card reaches Review, the question is not "did the agent say it worked" but "is the evidence here."
What Routa is good for, and what it is not
Routa fits teams and solo developers who already run agents in parallel and feel the coordination pain: several features in flight, several branches, several agents, and no single view of what is done. It also fits anyone who wants the audit trail, because every card keeps its trace and its evidence after the work is finished.
It is less suited to quick, single-shot prompts. If you just want one snippet or one small fix, a board with specs, lanes, and gates is heavier than a chat window. Geeky Gadgets makes the same tradeoff explicit: a steeper learning curve than chat tools, in exchange for structure. That is an honest tradeoff, and it tells you who should adopt Routa first: people whose agent usage already outgrew chat.
Getting started
The project offers a web app, a desktop app for macOS, Windows, and Linux, a command line tool installable with npm, and Docker images, according to its README. The practical starting point is small: pick one real feature, put it on the board as a single card, let the coordinator write the spec, and watch how the card moves through Dev and Review before you scale to five agents at once. The board will teach you Routa's discipline faster than any documentation page, because every rule shows up as a card that refuses to move until its evidence is in order.
If you already coordinate agents across tools, a related read is Agent Scripts: Share One Set of AI Coding Skills Across Claude Code and Codex.
Read this article in Indonesian: Baca artikel ini dalam Bahasa Indonesia.
FAQ
Is Routa open source?
Yes, under the MIT license. The source is public at phodal/routa on GitHub, and the project had 1,831 stars and 247 forks as of October 29, 2026.
Does Routa include its own AI model?
No. Routa coordinates other agents through adapters and protocols including ACP, MCP, and A2A. It does not ship its own model.
How do multiple agents avoid overwriting each other?
Each task runs in its own git worktree, a separate working copy of the repository, so parallel agents edit separate copies instead of colliding in one working tree.
What stops an agent from marking its own work done?
The review gate. A card moves from Dev to Review only after a commit exists and the worktree is clean, and it reaches Done only with an APPROVED verdict from the review process, which checks acceptance criteria, evidence, git state, and lint and type checks.
Can I run Routa locally?
Yes. The desktop app is local-first, favoring local agent binaries, local worktrees, and trace files, and it runs on macOS, Windows, and Linux. A self-hosted web mode is also available.
Is Routa only for teams?
No. Solo developers running several agents in parallel get the same benefit: one board showing every task, its evidence, and its review state, instead of several chat threads to keep in mind at once.