If you run AI coding agents daily, you’ve felt the shift. A year ago, the bottleneck was generating code—waiting for Claude or Codex to produce a function. Now that generation takes seconds, the constraint moved upstream and downstream: manually translating meeting notes into tasks, and individually reviewing every PR. Amdahl’s law applied to agent workflows: the part you haven’t automated dominates total time.

PlanWright is the first tool I’ve seen that treats this as a systems problem rather than a process reminder. It’s a control plane that orchestrates multiple AI coding agents through a shared state machine—Scheduled, In Progress, Acceptance, Done—with every transition signed via ECDSA P-256 and hashed into an immutable chain. It connects to Claude Desktop, Claude Code, Cursor, Codex, and any MCP-compatible agent. Planning and acceptance still happen, but with inverted control: agents draft the plan and check the mechanical criteria; humans approve or reject.

I’ve been running a mix of Claude Code and custom agents for contract-generation workflows at our SaaS platform. The unaudited, ad-hoc Kanban board we use now is the weak point. PlanWright’s pitch—“agent drafts, you approve”—maps directly to how I want my team to work: less context-switching into Jira, more structured handoffs between agent types.

Why MCP matters more than another dashboard

PlanWright doesn’t replace your agents; it connects them via the Model Context Protocol. That’s a meaningful architectural choice. Instead of building API integrations for each agent vendor, you get a single MCP server that any MCP client can talk to. If you’re already using Claude Desktop or Cursor, you add PlanWright’s MCP endpoint and your tasks appear on a shared board. No new client, no credential management per tool.

The trade-off is MCP’s current adoption. Not every coding agent supports it yet—some still require custom plugins. PlanWright’s GitHub shows TypeScript and Python MCP implementations, so extending it is feasible if you’re comfortable with MCP internals. For a team with a heterogeneous agent setup, this might mean writing adapters. But the protocol is open and gaining momentum; betting on MCP over a proprietary API seems sensible given the landscape.

The audit trail as a feature, not a compliance checkbox

The hash-chained, signed transition log caught my attention beyond the compliance angle. It means every step—who assigned the task, which agent executed it, who approved—is cryptographically verifiable. For SOC 2 auditors reviewing AI-generated code, this is the difference between “we have logs” and “here’s the chain of custody for each change.” PlanWright offers retention tiers from 30 days (free) to 7 years (enterprise). If your team ships code that feeds into regulated workflows, this isn’t a nice-to-have—it’s the only credible answer to “how do you know the agent didn’t hallucinate a backdoor?”

The signing overhead is negligible per transition, and most teams already check JSON output from agents. Changing that to a signed hash adds minimal friction. The real cost is changing habit: having agents report state into PlanWright instead of just dumping results into Slack.

Does “invert planning and acceptance” hold for real teams?

PlanWright’s core claim: planning should be “agent drafts, you approve” and acceptance should be “machine checks mechanical criteria, human judges edge cases.” That works when your planning input is structured—meeting transcripts, Slack threads, existing specs. It works less well when the plan itself is vague and the human needed to refine it interactively. I’ve found that for greenfield features, I still prefer to sketch the architecture myself before letting an agent draft subtasks. PlanWright’s model assumes you can provide enough context for the agent to produce a reasonable plan. That’s a strong assumption for early-stage design.

Similarly, acceptance: if your code quality checks are deterministic (lint, type-check, test coverage), PlanWright can route those to a triage agent automatically. But “mechanical criteria” for, say, security-sensitive logic is hard to formalize. The tool leaves room for custom acceptance agents, but you’ll need to define those criteria yourself. No magic bullet.

The verdict for teams

PlanWright is a credible first attempt at solving the orchestration bottleneck. The MCP-based integration keeps it agent-agnostic. The audit trail is genuinely useful beyond compliance theater. The pricing ($15/seat/mo for teams) is reasonable for what you get—a shared state machine with version control for tasks, not another chat interface.

But it’s early. The HN Show HN has two comments. The documentation is thin on multi-agent conflict resolution (what happens when two agents claim the same task?). And the “invert planning” thesis assumes your team has the discipline to review agent-drafted plans before execution—a cultural shift, not a technical one.

I’m integrating it as a trial for our contract-generation pipeline this quarter. The most promising signal: it treats human time as the expensive resource and asks agents to compress it, rather than asking humans to oversee every step. That’s the right intuition. Now we need to see if the machinery is robust enough for weekly throughput of dozens of agent-written PRs.