Kyzo Plan

You decide what's worth building and write it once — agents execute against that
judgment, gated on git, with a judge before every checkbox and a token meter kept lean by design.

Kyzo Plan is a control plane for people who still own the product judgment — and for agents that must not re-derive it. Intent is written once, upstream, as an execution contract. The board is shared state, not a handoff chain. 35 typed MCP tools operate it; git and a completion judge keep motion honest. A checkbox is a fact, not a self-attestation.

Install

Requirements: uv on PATH, gh authenticated against the board's GitHub org, Python 3.12+.

Claude Code

/plugin marketplace add https://github.com/kyzodb/plan
/plugin install kyzo-plan@kyzo

Zero config in the common case: board owner and repo come from origin, project number from the repo's sole open linked GitHub Project. create_board provisions a fresh board with this schema if you're starting from nothing.

Overrides on enable (/plugin configure kyzo-plan@kyzo) or at install:

claude plugin marketplace add https://github.com/kyzodb/plan
claude plugin install kyzo-plan@kyzo \
--config board_owner=OWNER --config board_repo=REPO --config board_project=N

Cursor — same skills, agents, and MCP server. Claude Code is the supported install from this repository today.

Uninstall with /plugin uninstall kyzo-plan@kyzo. Board state lives on GitHub; uninstalling leaves nothing behind.

One ledger — no translation layer

What you see is what agents operate. Stock GitHub Projects; one screen is the working truth — not a status chain between roles:

Epics carry roll-up progress (1 / 3 — 33%). Classification is the GitHub label. One card in In Progress answers what is being built right now. Filter Backlog and Done away:

Where the tokens go

Agentic cost is mostly input: context re-read on every step. Five drains, five mechanisms — thinking stays upstream; agents don't burn the meter rediscovering it:

One axis, horizons on epics

A grammar, not a manual

The kyzo-plan-manage-board skill carries what lives between the tools: orient with read_board_status, never work around a refusal, never touch the board through raw gh.

The lifecycle refuses until reality agrees

Branch-per-epic, one story at a time. The board cannot outrun the repository. start_epic demands a clean, up-to-date main and an unused branch. start_story demands HEAD on that branch, stories in sub-issue order, and prior work physically present. finish_epic refuses until every box is checked and the branch has no commit missing from main — it verifies the merge; it never performs it.

Judgment in, once

The hard work is still yours: what this serves, what dies, what was chosen, and how done is proven. Skills kyzo-plan-write-story and kyzo-plan-write-epic hold the shapes. You commit:

• Sources / Condemned / Ceiling / Engineering Choice — the product call, crystallized so an agent cannot reopen it as exploration.
• Context — exact references; only genuine unknowns marked [OPEN].
• Tasks — append-only T# with Allowlist: and a fast Check:.
• Definition of Done — exactly one Final QA item (check_final_qa). No Witness/CI/worktrees in the contract. Allowlist commit is the seal.

Banned lexicon (improve, polish, for now…) stays out of tasks — or lives only inside Condemned, naming what is being killed. Agents execute the contract; they do not re-author the judgment.

Watched at the call

The spawner runs under zero trust: this agent will deviate; an unwatched deviation is the spawner's fault. Paths are law. A live session:

Orchestration lives in kyzo-plan-run-story: allowlist arming, XML spawn, path watch, parent check, judge after verify_task_completion, allowlist commit (the seal), Final QA + check_final_qa.

Built by Kyzo

Kyzo Plan is the system KyzoDB is built with — these screenshots are its live board. It does not use or require KyzoDB. We needed a control plane we could trust with agents; we built it, we run it every day, and it earned a release of its own.

Next in the line: Codegraph — measuring whether each change moves a codebase toward the architecture its team intends.

License

Business Source License 1.1 — free to use, modify, and build on for any non-production purpose; production use requires a commercial license until the Change Date, after which it converts to MPL-2.0. See LICENSE.