Agents that ship.
Prototyper ships with six built-in agents — and any external one you mount via MCP — sharing one workspace. They read your files, write to your apps, and open real PRs. Presence on the canvas, not a sidebar.
They write real code. And they open the PR.
They ship, not chat.
Real React, your tokens, your conventions. They fix their own compilation errors and open PRs — not snippets, not React-shaped fragments.
Watch them workThey share the room.
Six built-in agents. Spawn three, watch them merge cleanly. Presence on the canvas, not buried in a sidebar.
See the dispatchBring your own brain.
Mount Claude Code, Codex, Cursor or another MCP client. Pay your existing subscription. Same canvas, different brain.
Mount anywhere
Watch them work
What every agent does on the canvas.
They write real code.
Not snippets. Not React-shaped fragments. Typed React + Tailwind that follows the conventions already in your repo.
They use your tokens.
Your colors, spacing, radius, and typography — respected on every render. No off-brand surprises landing on the canvas.
They sharpen the brief.
Vague idea in, structured spec out. The agent fills in the edge cases, the loading states, the responsive behavior you forgot to write down.
They fix their own work.
They read compilation errors and console output, then patch until it runs clean. You see the fix, not the failure.
They branch to explore.
Fork one conversation into three. Three takes on the same brief, side by side. Keep the yes, archive the nos.
They build a design system.
Tokens, ramps, typography, dark mode — all from a brief. Then every later thing they ship uses it.
They review before shipping.
Accessibility, performance, security. Caught on the canvas, not in production.
They coordinate.
Spawn a builder, a tester, a reviewer. They share the same files, watch each other work, and merge cleanly.
They run, not render.
Every change recompiles in the browser. What you see is the running app, not a static thumbnail.
Mount it anywhere you already work.
You don't have to leave Cursor, Claude Code, or your terminal. Prototyper plugs into whatever you already use — your stack, your subscription, your shortcuts. Why the surface and the agent stay separate: what an AI agent workspace is.
Mount it as an MCP tool.
Already in Cursor? Mount Prototyper as an MCP server and let your editor agent build entire components without leaving the buffer.
Bring your subscription.
Pay flat-rate to Anthropic and run your UI generation on your Claude Code plan. No per-token Prototyper bill.
Same canvas. Different brain.
Plug in your OpenAI Codex agent and watch it share the canvas with claude-code, the workspace builders, and your teammates.
Ship it as a pull request.
Mount your repo in the workspace. Your agent commits to a working branch and opens the pull request for review.
No agent of your own yet?
The Prototyper agent is built in, with the same tools and the same canvas. Steer it mid-task, or branch it to try three takes.
One protocol. Every tool.
If it speaks MCP, it gets the entire Prototyper toolset. No custom integration code, no glue layer to maintain.
The whole stack, not three tools you glue.
The agent
- Built in, or your own over MCP
- Steering — redirect an agent mid-task
- Branching — fork to explore three takes
- Reads and writes the files your team does
- Opens pull requests on a mounted GitHub repo
The canvas
- Infinite surface, one workspace
- Multiplayer — cursors, bots, selections
- Every panel is a draggable node
- CRDT sync — no conflicts, no loading screens
- Arrange it the way you actually think
The experience
- Open a workspace in one click
- No config files, no setup wizard
- Claude Code, Codex, Cursor or another MCP client
- On paid plans, your agent exports the code
- Share a link to the running app
Spin up the dispatch.
One workspace. Several agents already on it. Your file tree, your tokens, your subscription. Open it and let them start.