Quick answer
- What it is
- A live board where each card is one AI agent working one story on its own branch
- What a card shows
- Agent (Claude Code / Codex), branch, current status, output tail, and the diff
- Single-agent friendly
- Works with one agent at a time, parallelism is optional
- Pricing
- Included in the free tier (1 project) · Solo $19/mo
Why Coding Agents Need a Board
The moment you open a second Claude Code session, you have a visibility problem. Each terminal shows one agent's wall of output; nothing shows you the whole picture. Which agent finished? Which one hit an error twenty minutes ago and has been sitting idle since? A multi-agent workflow lives or dies on being able to answer those questions at a glance.
Terminal tab blindness
Lost context
Missed failures
No overview
A kanban board solves all four with one paradigm: each story is a card, each card mirrors live agent state, and the column tells you where attention is needed. This is what makes AIDEN an agentic IDE rather than a fancier terminal.
The Five Columns: A Story's Lifecycle
AIDEN's board mirrors the natural lifecycle of an agent-driven story. You move a story into Spec Review and approve the spec; from there, the agent drives the transitions.
Stories
A story is a plain-language description of one unit of work, "Add OAuth login with GitHub" or "Fix the memory leak in the sync worker." Stories sit here until you're ready to hand one to an agent.
Spec Review
AIDEN drafts a spec from the story: goal, acceptance criteria, files likely to change, boundaries the agent must respect. You edit and approve it on the card. This gate is enforced, since v1.5.21, no agent starts coding without an approved spec.
In Progress
The card shows the branch name, the CLI running it (Claude Code or Codex), the agent's current action, and a live tail of its output. The agent can run tests and iterate on failures, best-effort, not a guarantee. Several cards can sit here at once; that's the point.
Review
The agent is done. The card shows the full diff and a summary of what changed. You read the diff, optionally trigger the LLM review pass for a second opinion, then open a GitHub PR with one click, or send the story back with a comment.
Done
Merged stories land here and AIDEN cleans up the worktree. The card stays searchable, the original story, approved spec, agent log, and final diff are all preserved, so you can always reconstruct why a change was made.
The yellow column is the load-bearing one. The spec, not the prompt, is the contract between you and the agent, and the approval gate is the one hard checkpoint before code gets written. How to write specs that agents execute well is its own topic: see spec-driven AI development.
Ship your first agent today
Download AIDEN free and point it at your existing Claude Code or Codex setup. No credit card, running in minutes.
Download AIDEN freeFree to start · macOS 12+ · No credit card required
AI Kanban vs Traditional Kanban (Jira, Linear, Trello)
Traditional boards track human attention: a person picks up a ticket, does the work, drags it to Done. On an AI kanban board the work happens behind the card, you don't drag tickets, you watch them advance, and your job concentrates in two columns: Spec Review and Review.
| Dimension | Traditional kanban (Jira / Linear / Trello) | AIDEN AI kanban |
|---|---|---|
| Who moves cards | Humans, manually | Cards advance as agents progress |
| Update frequency | Once per status change | Live, every agent action |
| Card contents | Title, description, assignee | Agent, branch, status, output tail, diff, PR link |
| Blocked detection | Someone flags it | Agent exit marks the card, visible immediately |
| Spec / acceptance criteria | Optional free text | Structured spec with an enforced approval gate |
| PR linkage | Pasted into the description | One-click PR from the card |
| Bottleneck | Team velocity | Your review throughput |
AIDEN is not a Jira replacement, it's the layer between your backlog and your codebase. High-priority Linear items become AIDEN stories; agents implement them; you merge the PRs and close the tickets. The two systems complement each other.
Setting Up Your First AI Kanban
Four steps from download to a working board. You'll need macOS 12+ and at least one of Claude Code or Codex CLI installed locally, AIDEN runs on top of them.
- 1
Create a project
Point AIDEN at a local git repository. It analyzes the codebase and builds a technical overview so agents start with full context. The free tier covers one project. - 2
Add stories
Write one card per deployable unit of work. "Implement rate limiting on /api/checkout" beats "Improve the API", specific stories produce specs an agent can actually execute. Give AIDEN a larger goal and it can suggest a breakdown. - 3
Approve the spec
Review the generated spec on the card, goal, acceptance criteria, boundaries, edit it if needed, and approve. The story moves to In Progress and the agent starts on its own branch. - 4
Watch the board, review the diff
Cards update as agents work. When one reaches Review, read the diff, optionally run the LLM review pass, and open the PR with one click. Then pull the next story.
How many stories to run at once depends on your machine, your model limits, and how fast you review, the tradeoffs are covered in parallel agents with git worktrees. And if you'd rather not touch the keyboard to launch the next story, AIDEN's voice orchestrator can delegate a task by push-to-talk.