Introduction
Planwright is strategic execution infrastructure
Planwright is the planning layer built for the way software actually gets written today — by humans setting direction and coding agents doing the work. The model in one line: humans own direction, agents do the work. Everything else follows from that.
Traditional trackers weren't built for this
Jira, Linear, and their peers were designed for a specific era: human engineers breaking stories into subtasks, sprint planning in two-week cycles, low-velocity handoffs between PM and engineering. That model made sense when humans were the execution unit. AI-assisted and agentic teams have outgrown it. Bolting AI features onto those workflows — or forcing agents to operate like slow humans — compounds the mismatch instead of resolving it.
Granular tasks, subtasks, and estimates written by engineers
Outcomes (Objectives) owned by humans — written solo or co-authored with an agent; agents execute and decompose
Days to weeks per ticket; backlogs measured in sprints
Hours to days per Objective; no sprint ceremony required
Story points, burn-down charts, capacity planning
Objective latency and pass/reject ratios — no estimation theater
Browser UI — engineers click to move tickets between columns
MCP protocol — agents call structured tools to claim and check in
Best practice to review before merging; easy to skip under pressure
Structurally enforced — agents cannot self-approve, ever
Status comment or activity log — "moved to Done by @engineer"
Cryptographic attribution chain — agent, model, human approver, signed
If your team is using AI today, you're already feeling this
You don't need a fully agentic pipeline to notice the friction. The moment AI is writing, reviewing, or shipping code in any meaningful volume, your existing workflow starts showing its age.
Your board stops reflecting reality
Agent work happens outside the tracker. By end of week, nobody's sure what's actually done, what's in-flight, and what was quietly abandoned mid-session.
With Planwright claim, in-progress, and completion are tool calls the agent makes as it works — not status updates anyone has to remember to file. The board reflects reality because agents update it directly.
Human review has no dedicated home
Review happens in GitHub PRs — if it happens at all. There's no structured interface for the actual question: did the agent implement what we asked?
With Planwright a structured acceptance gate surfaces that question directly to whoever owns the Objective — separate from the PR, always answered before work is marked done. Agents cannot self-approve.
Intent dissolves between sessions
What an objective means to leadership, what an engineer briefed to the agent, and what the agent shipped diverge quietly over time. The drift is invisible until it ships.
The Planwright Objective — the human-written statement of intent — is permanently attached to every agent run. The original direction is always visible alongside what shipped.
The context that built it disappears
Prompts, constraints, and design reasoning live in a chat window. When the session closes, they're gone. The next agent — or the next person — re-derives everything from scratch.
The Planwright audit chain stores the full record: plan, diffs, notes, and acceptance decision — permanently attached to the Objective, not in a chat window that closes.
Planning ceremonies stop measuring anything real
Sprint velocity and burndown charts assume humans are the bottleneck. When an agent closes a week's worth of work in an afternoon, those numbers become fiction.
The Planwright Objective latency and pass/reject ratios replace them — the metrics that actually reflect how agent-assisted teams move. No estimation theater.
"Who approved this change?" has no answer
Agents generate and ship code, but your PM tool records nothing. The question compliance will ask first is the one your tools can't answer.
With Planwright every state transition is recorded — agent, model, human approver, timestamp — cryptographically signed and independently verifiable. The answer is always there.
"What is AI actually delivering for us?" has no answer
The tool spend is on the invoice. The outcomes aren't anywhere. There's no connection between which agents ran, which Objectives they served, and what shipped.
With Planwright every agent run is tied to an Objective with a human acceptance record — the first real data on what AI delivered and where it had the most impact.
What Planwright is
Control plane for autonomous agents
The planning unit is the Objective — a clear, atomic outcome a coding agent can execute. Not a story. Not a ticket. Not a subtask. Objectives are owned by humans — written solo or co-authored with an agent through collaborative brainstorming of intent and outcomes. Once scheduled, agents pick them up, decompose them, and check in against them.
Native MCP server
Claude Code, Cursor, Codex, and Amp connect directly via the Model Context Protocol. Agents use tools like claim_objective and request_acceptance — designed for an agent's mental model, not wrapped from a human API.
No intermediary between human and agent
Because the board is fully operable over MCP, planning discipline comes at no administrative cost. The agent claims an objective before writing code, posts a decomposition plan before making changes, and requests your review before marking work done — all via tool calls, without you maintaining a tracker in parallel. Structure that traditionally required engineering discipline to enforce now enforces itself, because the agent does the enforcement as it works.
Human acceptance gate
Agents cannot mark work as done. Every objective must pass through a human review before reaching the Done lane. This is the SOC 2 change-approval control point — not a workflow option, a hard constraint enforced by the state machine.
Cryptographic audit chain
Every state change — lane transition, agent run, acceptance, initiative release — is written to an append-only, hash-chained, ECDSA-signed ledger. Each workspace has its own signing key in AWS KMS. The chain is independently verifiable; no Planwright login required.
Any team, not just engineering
GTM, product, ops, and compliance teams run objectives and agents without a linked repository. The audit chain, acceptance gate, and Strategic Focus taxonomy apply to any outcome — not just code commits. A GitHub repo enables commit tracing; it is not a prerequisite for anything else. See Beyond Engineering.
What Planwright is not
Not task management
There are no subtasks, checklists, or breakdowns inside an Objective. Decomposition is the agent's job. If you want a checklist, give it to Claude Code — it doesn't belong on the board.
No story points or velocity
Planwright does not track estimates, burn-down charts, or capacity. This is a product principle. We track latency and pass/reject ratios because those are meaningful; velocity math is not.
Not a code reviewer
Planwright records what was changed and who approved it. Static analysis, SBOM generation, and security scanning belong in your CI pipeline.
Not a Jira replacement
If your team needs epics, subtasks, custom fields, and sprint boards, Jira is already built for that. Planwright can seamlessly integrate with Jira and other issue traickers but its core value is for teams that want to give coding agents structured work and maintain cryptographic proof of human oversight.
Planwright fits in — it doesn't replace
There's no migration, no retraining, and no process redesign required to start. Planwright adds a layer of structure to what you're already doing.
No ticket migration. Start adding Objectives for new work alongside whatever you use today. Jira and Linear keep running.
No new accounts. Login is GitHub OAuth — everyone on the team is already set up.
No integration work. Claude Code, Cursor, Codex, and Amp connect via the MCP protocol they already support. No custom wiring.
One repo to start. Connect a single project, run a few objectives, and expand when it’s proven its value.
Teams typically go from zero to first accepted objective in under an hour.
The mental model: Humans own Objectives and set strategic direction — writing them solo or co-authoring with an agent through brainstorming of intent and outcomes. Agents claim Objectives, post a decomposition plan, execute, and request review. Humans accept or reject. Every step is recorded in the audit chain. Objectives are grouped into Initiatives, which can be released as signed version artifacts. Strategic Focus classifies the work as BUILD, GROW, TRUST, or SCALE. This model applies to any team — engineering, GTM, ops, compliance — with or without a connected GitHub repository. That's the whole system.