Introduction
What is Planwright?
Planwright is mission control for your coding agents. It makes sure they build what you meant, and it proves they did.
The hard part moved
Coding agents made writing code cheap. The hard parts are now at the two ends: saying clearly what you want, and checking that what came back is actually right. Most teams are winging both. Planwright handles those two ends, and the agent does the work in between, in whatever tool the developer already uses.
Your coding agent is a brilliant new hire who starts from zero every morning
It's fast and capable, but it will confidently build the wrong thing if you're vague. It won't remember yesterday's decisions, it will tell you it's done when it isn't, and it leaves no record of who approved what.
Planwright is what that new hire needs: a clear brief every morning, a person who checks the work before it counts, and a record of everything that happened.
Five steps: ask, build, check, ship, learn
Every piece of work goes through the same five steps. People ask and check. Agents build. Shipping and learning happen on their own.
How Planwright works walks through each step and the features behind it.
One piece of work, start to finish
Say your product lead wants users to be able to reset their password by email. It comes up in a planning call, and their agent turns the transcript into an objective under the Account security initiative, with acceptance criteria: the link arrives by email, it works only once, and old sessions get signed out. It's an outcome, not a task list. The lead approves it, and Planwright checks that it's clear enough for an agent to work on.
A developer's coding agent picks it up. Planwright hands it a brief: here's the goal, and by the way, the last couple of sign-in changes were rejected for missing tests. The agent posts its plan, and it can't start editing until it confirms the plan matches the goal.
When it's done, it attaches the code changes and test results and asks for review. The reviewer checks the work against the acceptance criteria and sees a flag that it touched authentication code, so they look closely. They approve it. When it merges, Planwright marks it released and adds it to the changelog.
If it had been rejected, the reason would go into the next agent's brief, so the same mistake doesn't happen twice.
The acceptance criteria are the contract. The agent builds to them, the reviewer checks against them, and rejections tell you when they were missing.
What an objective carries
The objective is the unit everything else hangs off. The intent part is drafted by an agent from your transcript, spec or request, usually with a person steering, and a person approves it. Planwright fills in the rest as the work is scheduled and done. Because it carries its own intent, context and history, a fresh agent session can pick it up, and a reviewer can judge it without digging through chat logs.
From one feature to a whole product
It works at any size. Hand an agent a whole product spec and it plans the lot: dozens of objectives grouped into initiatives in delivery order. The first initiative is the smallest version that works, and each one after it leaves the product usable. Every objective is a thin slice that ships and gets checked on its own. The plan lands in the backlog, and you decide what gets scheduled and when.
When will it land?
Turn on the forecast on the roadmap and every initiative gets a projected finish date, and its place in the finish order. The dates come from how long agents and reviewers have actually taken on this project, worked out across every initiative at once, so they compete for the same people and agents the way real work does. Nobody estimates anything.
Then ask what if: add an agent, add a reviewer, or speed up reviews, and watch the dates move, without touching the real plan. Forecast when initiatives will land walks through it.
What you get without maintaining anything
Because every step runs through Planwright, the rest comes from what agents and reviewers actually do. Nobody updates a status report.
A live board
Every objective, from proposed to released, with who's on it and when it last checked in.
A roadmap that draws itself
Each initiative becomes a timeline bar, with its dependencies, built from its objectives and target date.
A forecast
When each initiative will land, worked out from how long agent runs and reviews actually take. Nobody estimates anything.
How it works →Metrics that mean something
How often agent work passes review the first time, where work waits, and what keeps causing rework.
Release notes and a changelog
Written from completed objectives, so nobody writes the weekly summary.
Proof
Every step is recorded and signed, so you can show an auditor or a customer what changed and who approved it.
That record is a hash-chained, signed audit trail, designed to map to the SOC 2 criteria for AI-written code. Anyone can check a workspace's audit export with standard tools.
What developers get
No tangents. When a side idea comes up mid-session, your agent parks it as a new objective, and you finish what you started.
A fresh session per objective. Each objective carries its own intent and context, so you can clear your agent's session after every one. Smaller context means fewer tokens, so a paid plan goes further, and the agent stays sharp.
Your agent, your workflow. Claude Code, Claude Desktop, Cursor, Codex and Amp connect over MCP. Planwright doesn't wrap or proxy your agent; it's a set of tools the agent calls, and the process comes with them.