AI code you can ship.
Kaichi is a context manager and state-governance MCP that uses AI to build production-grade software — architected, tested, reviewed, and fully documented. Code your team can merge, own, and stand behind. Not a prototype to rebuild.
We run Kaichi on your repo — you review, merge, and pay only for what you merge · or install free for solo & OSS work
It ships real code.
Production-grade and ready to merge — no drift, no context rot, and nothing for your engineering team to clean up and productionize. The output isn't a draft of the work; it's the work.
- ✓No drift — a no-code, deterministic state-management system keeps the LLM on track across tens of thousands of lines of code.
- ✓No context rot — Kaichi digests context at scale into memory-wiped stages with verifiable proofs that guarantee the definition of done.
- ✓No productionizing phase — it lands production-grade; your team merges it, they don't rewrite it.
Documented like a real engineering org.
Not code dumped in a PR. A full paper trail — product, architecture, and design — with the reasoning checked in next to the diff, so the next engineer can actually own it.
- ✓PRDs, ADRs, and design docs — written for humans, generated as part of the work, not bolted on after.
- ✓Proof-of-thought — the chain of reasoning ships with the code, so every decision is traceable.
- ✓Reads like the mind of an engineer — no black box, no re-deriving intent six months later.
One plan. Versioned in git.
Kaichi's state — the roadmap, every card, the reasoning — lives in git, right next to your code. Your team collaborates the way it already does: branch, review, merge. There's no second system to keep in sync.
- ✓A real roadmap — milestones, stories, and cards in a navigable plan of record that humans and agents both work from.
- ✓Git-native — the whole board is version-controlled markdown. Share it with push/pull, review it in PRs, diff it like code.
- ✓One source of truth — people and agents work off the same plan, so what's planned and what ships never drift apart.
This is how software is really shipped.
When you're shipping to a billion users, software isn't vibes. It's a brutal, unglamorous process most people never see: requirements pinned down, architecture argued out and recorded, designs torn apart before anyone writes a line, code reviewed, tested, staged, and signed off. That process — the Software Development Lifecycle — is the only reason a stack that size doesn't fall over.
Vibe coding throws all of it out: generate something plausible, eyeball it, ship it, hope. Fine for a weekend toy. A liability at scale.
Kaichi puts the lifecycle back. It does the real engineering — requirements, design, build, test, review — and leaves the documented trail behind every decision. You can hand the work to AI and still answer for it: the diff survives review, the docs are there, and every claim is checked against a gate before it advances.
It's the AI harness you can actually bring to work — code that holds up, documentation that's real, and a trail you can stand behind.
Autonomous development that fits how your team already works.
Point it at a goal and it runs the whole process like a disciplined team — every stage produces a real artifact and passes a gate before the next begins.
The single plan of record a whole org works off of — every milestone, story, and feature in one place. Kaichi operates at that altitude: roadmap-level autonomous development, not one-off prompts.
Scoped agents build each piece in its own worktree, test-first against the spec — parallel and conflict-free.
One gated, fully documented pull request — reviewed, merge-ready, and yours to own the moment it lands.
Every stage passes a hard gate before the next begins — the work has to match its spec to advance. That's the difference between an agent that runs and an agent you can leave running: what lands is reliable because the process, not luck, produced it.
Documentation your team will actually use.
Every feature ships with the reasoning right next to the diff — requirements, design, and decisions, written for a human to read. Not code dumped in a PR: the same documentation your best engineers would leave behind, so the work is truly yours to own six months later.
Present it to leadership
Walk a VP, an auditor, or a security reviewer through the decision trail — PRDs, ADRs, and design decks that read as a plan of record, not a black box. Review-ready the moment it ships.
Hand it to your engineers
It reads like a teammate wrote it, so it survives code review — nobody's rewriting AI slop. And it drops into the SDLC you already run: branch, PR, review, merge. No new process to adopt, no second tool to babysit.
PRD → Design → ADR · the same paper trail lands with every feature
AI code you can actually ship.
Stop paying for prototypes. Scoped, disposable agents turn spend into shipped software — one Claude Max account ships daily.
A fully documented product, architecture, and design — with as-built specifications and a complete, human-readable chain of reasoning.
A custom test plan for every change — true test-first execution, not tests slapped on after the fact, so there's no separate testing phase.
Pure spec-driven execution with deterministic stage gates — roadmap-scale autonomous delivery of production-grade software.
What's in the box.
Complete engineering documentation, specs, and reasoning — written for people, checked in with the code.
Runs fully offline with zero telemetry. Nothing leaves your machine — built for regulated and air-gapped systems.
No-code setup that drops straight into your Claude Code CLI. No new runtime, no rewrite.
Disposable agents each build in their own git worktree — parallel, scoped, and conflict-free by construction.
Deterministic gates between every stage. Work can't advance until it matches the spec — no silent drift.
The chain of reasoning is captured as code, alongside deterministic logs — every change is auditable after the fact.
Tokenmaxing — spend that actually ships.
Most AI spend produces rework and prototypes. Kaichi turns the budget into shipped software — scoped, disposable agents that capture only what they need and exit. Yield, not rationing.
Real deliverables out of a single seat's budget — not a bigger token bill.
Most AI spend today is rework and unshippable output. Kaichi converts that waste into shipped software.
On a team, the recovered output dwarfs the cost — the ROI math isn't close.
Start free. Scale when you're ready.
Free for any individual and any non-commercial or open-source work, regardless of headcount. When it's time to use Kaichi commercially, we'll help you get there.
For individuals and open-source work. Boots straight into the Community tier — download the binary, point Claude Code at it, and you're running.
- ✓ The full harness — every feature
- ✓ Air-gapped, offline, zero telemetry
- ✓ No seat limits, no headcount cap
You don't install anything. A team operates Kaichi on your codebase and opens merge-ready PRs. Your engineers review and merge — learning it as they go — then move to a commercial license when they want to run it themselves.
- ✓ We work inside your repo, pushing PRs for review
- ✓ Your team reviews, merges, and learns it as we go
- ✓ Commercial & site-wide licensing for regulated / air-gapped orgs
Run free in 30 seconds.
Kaichi boots free in Community with no license — grab the binary, point Claude Code at it, and you're running. A Commercial license unlocks commercial use later: same binary, no reinstall.
Not sure which? Run uname -m — x86_64 or aarch64 (arm64). macOS & Windows builds coming soon · all releases & checksums →
- ✓ Runs free — the Community tier needs no license; download and go.
- ✓ One file — a single self-contained binary, no runtime to install.
- ✓ Verifiable — every release ships SHA256SUMS so you can check the download.
Alpine/musl? The binary is dynamically linked against glibc (≥ 2.28), so it can't start on musl-only systems. Workaround (unofficial): install a glibc shim (apk add gcompat) or run inside a glibc container (e.g. debian:12-slim).
We run Kaichi. You merge the PRs.
You don't install anything. Give us access and our team operates Kaichi on your codebase, opening merge-ready PRs — Kaichi does the engineering, we drive it, your team reviews and merges on their own terms. No scoping deck, no statement of work.
We run Kaichi on your repo → merge-ready PRs → you pay on merge.
- ✓ Pay on merge — billed only for the PRs you actually merge, never for work you don't ship
- ✓ We work like a teammate inside your repo — not an outside project
- ✓ Every change arrives as a reviewed, documented PR you control
- ✓ Your engineers learn it in-flow, then take the wheel on a license
See Kaichi ship on your codebase.
Book a 30-minute call. We'll run Kaichi on a repo you pick and have a merge-ready PR in front of your team in a few hours — you only pay for what you merge.
Not ready to talk? Join the Discord and lurk, ask questions, or watch what ships.