Design Tools Should Speak the Agent’s Language: What Paper Gets Right
The best design surface for an AI agent is the one it already speaks. Tools that force agents to translate (proprietary binary documents, screenshot-to-code guesses, vector editors reached through plugin APIs) pay a translation tax in accuracy, tokens and round-trip fidelity. Tools that make the design artifact itself the interchange format remove that tax. Paper is the clearest current bet on this principle: a canvas built on real HTML and CSS, with a first-party MCP server that lets agents read and write the same artifact a browser renders. This review is based on Paper’s documentation and one dated third-party review. We did not run Paper ourselves.
The Principle: Design in the Agent’s Native Language
Most design tools store work in formats agents cannot read natively. An agent then has to infer layout from pixels, reverse-engineer a plugin API, or accept a lossy export, and each hop costs tokens and adds ambiguity. Paper’s homepage describes the goal as “design to code and back”: the canvas is HTML and CSS, so the working format and the export format are the same thing. That is a design principle, and it is the right lens for judging agent-facing design tools. Whether it produces better agent outcomes is an open question. The integration architecture is at least consistent with the thesis.
What Paper Is
Paper is available as a web app and as Paper Desktop. Per Paper, agents can sync design tokens, styles and components between a codebase and the canvas, and the canvas “means your design exports as code.” Paper also says its MCP integration is “usually more accurate, faster, and more token-efficient” than other tools used with agents. That is a vendor claim we did not measure, so treat it as marketing language until someone benchmarks it.
Paper raised a $34M Series A from Accel and ICONIQ. That tells you about the company’s runway, not about product quality.
How the MCP Integration Works
Per the Paper MCP docs, setup starts by installing Paper Desktop, which starts the MCP server in the background and installs the Paper CLI. A “Connect your agent” dialog then offers one-click installs for Claude, Claude Code, Codex, Cursor, OpenCode, Antigravity, the GitHub Copilot app and VS Code. Any other agent can use a manual stdio configuration that runs the Paper CLI with the mcp argument. The docs also say the agent asks for permission before it uses the MCP server, a sensible default for a tool that can change a design file.
The docs suggest three first-run prompts: “Create a basic Hello World frame in Paper,” “Create 3 color tokens and make a swatch in Paper,” and “Generate an image of a beautiful sunset in Paper.” The Cursor marketplace lists the Cursor plugin. For the protocol itself, the Model Context Protocol defines the client-server model, and Anthropic’s MCP overview covers the Claude side.
The HTTP-versus-CLI detail
Older setups connected over Streamable HTTP at http://127.0.0.1:29979/mcp, which works only while Paper Desktop is open. The newer paper mcp CLI route lets agents see Paper’s tools even when Desktop is closed. The distinction is useful: tool discovery no longer depends on a window being open. Reads and writes to an open file still go through Desktop, so the CLI route does not remove that dependency.
Agent-Parseability Deep Dive
Round-trip integrity is the real test of an agent-parseable design tool. The question is not whether an agent can draw. It is whether the agent can read, edit and re-export without loss.
Machine-readable output
The canvas is HTML and CSS, so the export format and the working format are the same. No proprietary intermediate representation sits between them. Per Paper, “your design exports as code.” For an agent, this removes a class of translation errors: it does not have to guess at a binary document or rebuild layout from a screenshot.
Read and write over MCP
Per the Paper MCP docs, agents can read and write Paper files through MCP. They can generate a layout, pull in real content, or turn a selected frame into code. Read access matters because it lets an agent inspect the result of its own writes, but the docs describe the capability; we did not test how reliably it works.
Code round-trip
Paper’s homepage frames the loop as agents syncing tokens, styles and components between the codebase and the canvas. The docs describe selected frames becoming code. Both claims come from the vendor, and we did not verify how faithful the loop is on a real project.
What design signals leak, fix or hide
Paper’s docs include a guide to syncing design tokens from Figma. The guide lists gotchas, and they fall into two groups.
- Figma MCP limits: SVG fills often come back as images, and very large Figma files can make tool calls fail.
- Paper conversion limits: spacer elements are ignored, inset borders do not translate, and code-connected components are unreliable.
The first group is loss at the source, before Paper sees anything. The second is loss inside the conversion. Native format helps only for what survives the import. The canvas cannot restore structure or styling that the source tool already dropped.
Comparison: Agent-Facing Design Surfaces
This table is a capability map drawn from the sources cited in this review, not a benchmark. Cells marked “vendor claim” are unverified.
| Dimension | Paper | Figma with its MCP server | Screenshot-to-code tools |
|---|---|---|---|
| Working format | HTML/CSS canvas (vendor claim) | Proprietary document | Pixels in, code out |
| MCP exposure | First-party server, several named clients | Official Figma MCP server (per the Paper docs’ Figma guide) | Not described in our sources |
| Read and write | Documented for generate, read and frame-to-code | Documented for token and style sync; Paper docs list its limits | Not described in our sources |
| Code round-trip | “Design to code and back” (vendor claim) | Via token and component sync, with gotchas | Not described in our sources |
| Headless discovery | Tools visible via paper mcp with Desktop closed |
Not described in our sources | Not described in our sources |
The comparison is about where translation happens. Figma’s MCP path is an official integration that operates over a proprietary document model. Paper’s Figma guide shows what gets lost on the way in.
The Worked Example: Barley and Responsive Frames
The Paper MCP docs include a worked example. An agent builds the Barley website and generates responsive breakpoints from frames selected on the canvas, where each frame is one breakpoint. The agent then commits the work, and the docs say the site can be deployed to a hosting provider. The example shows the interface principle: selection is context. The human chooses the frames the agent sees, which turns a vague request such as “make this responsive” into a concrete set of inspectable frames. The docs do not show a deploy step, so we do not count one as demonstrated.
Limitations and Caveats
Paper is a single-vendor, closed tool. Per a third-party review, which comes from UXMagic, a competing AI design generator, tokens are per file: copying them to another file does not keep them in sync. Multiple theme modes are listed as planned, not shipped. The same review says Paper Desktop must be running for reads and writes to an open file.
Pricing comes only from that third-party review, which gives a free plan with 100 MCP tool calls per week and a Pro plan at $20 per editor per month, or $16 billed yearly. We did not confirm these figures on the Paper pricing page. The same review says Paper Desktop is available for Mac, Windows and Linux (AppImage).
FAQ
Do I need Paper Desktop running for agents to work? For the older HTTP endpoint at http://127.0.0.1:29979/mcp, yes. With the paper mcp CLI route, agents can see Paper’s tools when Desktop is closed. Reads and writes to an open file still require Desktop, per the third-party review.
Which agents does it support? Claude, Claude Code, Codex, Cursor, OpenCode, Antigravity, the GitHub Copilot app and VS Code have one-click installs. Any agent that accepts a manual stdio configuration can run <paper CLI path> mcp. The docs say the Codex install covers both the ChatGPT app and Codex CLI.
Is it free? The third-party review describes a free plan with 100 MCP tool calls per week and a Pro plan at $20 per editor per month, or $16 yearly. We did not verify this on the official pricing page.
Can it import my existing Figma files? The docs describe syncing tokens and styles from Figma through two MCP servers, Figma’s and Paper’s. They do not describe a whole-file import. The gotchas in the guide are listed in the section above.
Does the agent act without permission? No. The docs say the agent asks for permission before it uses the MCP server.
How We Tested
This review is based on the vendor’s official documentation, the MCP docs, and published third-party reviews — we did not run Paper ourselves. We read Paper’s homepage, the Paper MCP docs and one dated third-party review. Architecture is checkable from documentation: whether a canvas is HTML and CSS, whether an MCP server is first-party, and which clients it installs into are structural facts. Claims that need measurement are different. Token efficiency, round-trip fidelity across real projects, and breakpoint generation beyond the Barley example would all need hands-on testing that this review did not do.
The Bottom Line
Paper’s core principle is sound: the best design surface for an agent is the one it already speaks, and an HTML/CSS canvas removes a layer of translation. Its MCP architecture (a first-party server, several named clients, permission gating, and a CLI route that makes tools discoverable with the GUI closed) is well designed on its own terms. The unproven parts are the performance claim, the round-trip claim and the pricing. Paper is a good fit when the main consumer of design output is an agent or a codebase. It is a weaker fit for teams that need an open format or measured results today.