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.
See the full roadmap →
What we're building and why — pinned down and reviewed before a line of code exists.
Read a real PRD →
How it actually works — argued out and written down before the build, not improvised.
Read a real design doc →
The trade-offs that shaped it, recorded — so no decision is an unexplained black box.
Read a real ADR →
Scoped agents build each piece in its own worktree, test-first against the spec — parallel and conflict-free.
See the full board →
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). Verified by SHA-256 checksum — these carry no code signature. There is no macOS or Windows release build yet; unsigned nightlies for both are below · all releases & checksums →
Nightly — development builds off main. They clear the same build and license-gating smoke as a release, but they are unversioned, roll forward without notice, and are not what you want in production. They are published to this download point by hand, so check the date on the release before assuming a file is current.
Unsigned. The macOS and Windows builds carry no code signature — no Apple Developer ID and no notarization, no Authenticode — because we hold no signing certificate yet. A SHA-256 checksum is the only integrity they ship with, and your operating system will block the file before it runs.
macOS — the download is quarantined and Gatekeeper refuses to open it. Clear the attribute with xattr -d com.apple.quarantine kaichi-macos-arm64, or launch it once, let it be blocked, then allow it under System Settings → Privacy & Security.
Windows — SmartScreen shows "Windows protected your PC". Choose More info → Run anyway.
macOS and Windows cut 2026-09-19. The same SHA256SUMS file above covers all four assets.
- ✓ 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.
macOS / Windows? Both exist as unsigned nightly prereleases only — there is no release build for either, and no minimum OS version has been measured for them (Linux's glibc ≥ 2.28 floor is checked on every release; these are not). Whether they should count as supported platforms is an open question, so they are listed as their own state rather than promoted alongside Linux. If you search for how to open an unsigned Mac binary you will find advice to Control-click → Open — that override was removed in macOS 15 (Sequoia) and no longer works; use the quarantine or Privacy & Security route above.
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.