Routa: Kanban-Based Delivery Pipelines for Multi-Agent AI Coding
Routa is an open-source, local-first coordination layer for AI coding agents. Rather than a single chat thread, it organizes work as a Kanban pipeline where tasks move through Backlog, Todo, Dev, and Review columns automatically. Specialized agents handle each stage, and an evidence bundle (code changes, test results, command outputs, decision logs) accumulates as the task progresses.
Problems with chat-first AI coding
Most AI coding tools use a chat interface. For simple tasks this is adequate, but for multi-step software work it creates several reliability problems.
Lost context. Planning, failed attempts, workarounds, and final code all live in a single chronological thread. Retrieving a decision from 80 messages ago requires scrolling back through the entire conversation.
No traceability. The final code change is visible; the reasoning that produced it is not. Which alternatives did the agent try? Why was this approach chosen over another? This opacity makes code review difficult and means any learning from the session is discarded when it ends.
No quality gates. Standard software delivery includes automated test runs, linting, and criteria verification before code is merged. Chat-based AI tools bypass these steps unless manually prompted for each one.
How Routa addresses these problems
Routa maps each development task to a structured pipeline stage.
Task. Work starts as a clearly defined task with a description, problem statement, and acceptance criteria. These are not inferred from conversation; they are explicit fields attached to the task card.
Agent. A specialized agent (Coder, Reviewer, Tester) is assigned based on the current pipeline stage.
Review. Work passes through a review stage, either automated or manual.
Evidence. Each task accumulates an evidence bundle: code diffs, test results, command outputs, and decision logs.
Gate. Automated quality gates verify acceptance criteria before the task advances.
Setup
Routa runs as a local desktop application (macOS, Windows, Linux) or via Docker.
Creating a workspace
A workspace contains configuration for repositories, AI providers, and working mode. Create one from the home screen with a descriptive name.
Connecting an AI provider
Routa coordinates other AI agents; it does not include its own model. Navigate to Provider settings, select a provider (Claude Code for Anthropic, or another supported model), and enter an API key. Credentials are stored locally.
Adding a codebase
Add a local repository or clone one from a URL. Routa indexes the repository, making its files available to the agents.
Working mode: Sessions vs. Kanban
Sessions mode provides a more traditional advanced chat thread, suitable for exploratory work.
Kanban mode provides the full structured pipeline with automatic stage progression. Select Kanban for structured delivery work.
Kanban workflow
Creating tasks
In the Kanban view, enter task descriptions in the input field. Example tasks:
- "Extract routes into a Flask Blueprint (
auth_bp)." - "Use Flask flash messages instead of error query params for auth feedback."
Each task appears as a card in the Backlog column.
Automatic stage progression
Routa's coordination logic moves cards from Backlog to Todo to Dev without manual dragging. When a card enters Dev, the configured Coder agent begins working on it.
Task detail view
Clicking a card opens a structured detail view.
Left pane: task description, problem statement, and acceptance criteria.
Right pane: a live structured log of agent actions: ToolSearch, ReadFile, Search, code application. This is not a chat transcript; it is a traceable execution record.
Chat input: a prompt at the bottom allows interaction with the agent while it is working. Clarifications and redirects can be given without abandoning the task's structure.
Handoff and completion
When the Coder agent finishes, the card moves from Dev to Review automatically. A Reviewer or Tester agent picks up the task, analyzes the evidence bundle, and verifies that acceptance criteria are met. On successful review, the card advances to Done.
Final thoughts
Routa's core contribution is applying delivery pipeline concepts (stage-gated progression, evidence accumulation, specialized agents per stage) to AI-assisted coding. This solves the specific problem that chat-based tools cannot: maintaining structure, traceability, and quality checks across multi-step development work.
The tradeoff is setup time. Configuring a workspace, adding a provider, connecting a repository, and creating structured task descriptions requires more initial effort than opening a chat window. The return is a workflow where the agent's reasoning is logged, quality gates are enforced, and work history is preserved in a queryable form rather than buried in a thread.
For teams doing repeatable, multi-step development work where reliability and auditability matter, the overhead is justified. For quick one-off questions or exploratory work, Sessions mode or a simpler chat tool remains more practical.
Source code and releases are at github.com/routa-labs/routa.
This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License.