Self-hosted · MCP-native · Beta

Where your AI agents
work under review.

Your own coding agent drives a self-hosted board over MCP. Every task it does is independently reviewed and permanently recorded before it merges, instead of trusting raw agent PRs straight into your codebase.


The problem

Agents ship faster than anyone can review them.

The more work your agents do, the less of it a human actually reads. Raw output flows into the codebase, and later nobody can say what changed or who checked it.

Bare agents
Do the work — then hand you the diff.
Copilot, Cursor, Claude Code. Powerful, but the output lands with no process around it and no record of how it was made.
GitHub PR review
Enough — until nobody reads every PR.
Fine while a human reviews each change. It breaks the moment agents open more PRs than anyone reads, and it can't tell you which agent did what.
Daikonbun
Every task reviewed and recorded — structurally.
An independent review gate on every task, one the server won't let a card skip, and a signed record of exactly how the work was done.
How it works

Every task passes review before it merges.

Your agent plays each role in turn as a card moves through typed stages. At each gate an independent review produces a verdict and a score, and the server won't advance a card past it without one. Approve to continue, or send it back.

01 · Intake
Refiner

Refine

Turns a rough note into a clear task with acceptance criteria.

›
02 · Plan
Planner

Plan

Writes the implementation plan and decision log.

›
03 · Gate
Plan Reviewer

Review plan

Scores the plan. You confirm, or it loops back.

›
04 · Build
Builder + Test Author

Build

Implements the change and writes the tests to hold it.

›
05 · Gate
Code Reviewer

Review code

Reviews the diff for correctness and quality.

›
06 · Test
Verifier / CI

Verify

Runs the full suite. Green ships; red loops back.

›
07 · Done
—

Done

Merged, with the whole story on the card.

The Conductor is the agent you already run. Point it at the board and it drives the loop, playing each role, submitting its work for review, and moving the card toward done while you approve at the gates that matter.
Why it holds up

Reviewed, recorded, and entirely yours.

⌘

The card is the source of truth

Every plan, review, and test result is signed back onto the card. A resumed session, or a new teammate, can reconstruct exactly what happened.

⏻

Human-gated by default

It pauses at plan and code review. Full autonomy is opt-in, per run. You decide how long the leash is.

◎

Provider-agnostic

Agent roles are defined by function, not vendor. A routing table maps each role to whatever LLM you choose.

⬢

Self-host first

One docker compose up. Your data, your keys, your machine. Credentials encrypted at rest, never returned in plaintext.

↺

The gate can't be skipped

Review isn't a convention you can click past; the server enforces it. A card can't reach done without its tests passing. No faked completions.

▤

A board, not a chat log

Columns, cards, and a live feed of every agent action. Supervising a fleet of parallel runs is a glance, not a scroll back through chat.

Who it's for

Teams running agents on shared code.

When more than one person, and more than one agent, touch the same codebase, "who did what, and did anyone check it?" stops being answerable. That's who this is built for. Solo builders self-host free.

› Solo developers › Indie hackers › AI-native builders › Small dev teams & agencies › Anyone tired of moving cards by hand
Pricing

Free to self-host. A license when you ship for money.

Self-host it for noncommercial use, forever. When it earns, or a team leans on it, a commercial license keeps you square. Buy from anywhere; checkout and worldwide tax are handled for you.

▸ Watch a real review gate catch a bug. The governance you're paying for, in action. The paid features are free to try for 14 days.

Free
$0
Noncommercial self-host: evaluating, personal projects, anything that isn't making money.
  • The whole pipeline, self-hosted
  • Bring your own LLM
  • Single member
  • Community support
Get launch access
For commercial use
Commercial
$12 /seat/mo
Billed annually. Buy the exact number of seats you need, add more anytime.
  • Everything in Free
  • Commercial use
  • Multi-member: as many seats as you need
  • Audit export: the signed, attributed ledger
  • Priority updates & support
  • Free 14-day trial before you buy
Get early access

Audit export is the full signed, attributed ledger of a board: every stage transition and who approved it, as Markdown or JSON.  ·  14-day refund, no questions.  ·  Prices in USD; checkout, invoicing, and worldwide sales tax / VAT handled by Lemon Squeezy, our merchant of record.  ·  Not ready? Join the launch list.

Questions

What Daikonbun is — and isn't.

What is Daikonbun?
A self-hosted workspace where your AI coding agents work under review. Your own agent drives the board over MCP, refining, planning, and building, and every task passes an independent review gate before it merges, with a signed record of exactly how it was done. Daikonbun holds no model keys; your agent does the work on your own subscription.
How do my agents know how to operate it?
It speaks MCP. Point any MCP client (Claude Code, Cursor, or your own) at the board, and on connect the server tells it the whole workflow: the stages, the gates, and how to move a card. There's no plugin to write and no prompt to craft; your agent knows how to run the board out of the box.
Why not just my agent + GitHub PR review?
If a human reads every pull request, GitHub is enough. Daikonbun is for when your agents open more changes than anyone actually reviews. It makes review structural and agent-aware: an independent gate on every task the server won't let a card skip, and a record of which agent did what, not just "a human approved a PR." GitHub is your process until agents outrun hand-review; that's the line this is built for.
Does it run the agents? Do I pay per token?
No. You bring your own agent (Claude Code, Cursor, or your own) and it drives the board on your subscription. Daikonbun holds no model credentials and makes no model calls, so there's nothing to meter and no key to hand over.
Isn't this just a kanban board?
A board tracks work. Daikonbun governs it: a review gate on every task, enforced by the server, and a signed record of how the work was done. The columns aren't the product; the review and the record are.
Is it really self-hosted?
Yes. One docker compose up runs the board and its database on your own machine. Your data, your API keys, your infrastructure. A hosted option may come later, but self-host is the primary product.
Which AI models does it use?
It's provider-agnostic. Each agent role maps to a model through a routing table you control, so you bring your own LLM and route stronger models to planning and review, cheaper ones to mechanical steps.
Is my data private?
Because Daikonbun is self-hosted, your tasks, credentials, and work records stay on your machine. Credentials are encrypted at rest and never returned in plaintext by any API.
Is it available yet, and is it free?
Daikonbun is in beta: working software, pre-1.0. Join early access to self-host it as access opens up. It's free for noncommercial self-host, with a per-seat commercial license for paid use.
Wait — why "Daikonbun"?
Say it fast: daikon-bun. Yes — die, kanban. But the joke was never that we built a prettier board. Agents made "track the work" the easy part; the hard part is trusting what they shipped. So Daikonbun isn't a better board. It's the review and the record around your agents' work.
In beta · early access

Be first through the gate.

Daikonbun is in beta, pre-1.0 but working software. One email gets you early self-host access as we open it up, plus the docs and the day-one release.