Figma MCP server vs an agent design canvas: which to pick

Updated 2026-11-16

If a coding agent is the one designing your UI, pick chort, a $0 design canvas where the agent draws in real HTML and CSS. If the screens are already designed in Figma, pick the Figma MCP server. The maker of chort wrote this page.

Format, tools and code output side by side

Figma's MCP server works on designs stored in Figma's own proprietary format, while chort and Paper MCP keep the design as HTML and CSS. Rival facts come from Braintrust's eval of 20 July 2026, Figma's MCP guide read on 16 November 2026, Figma's agent announcement of 20 May 2026, Better Design's price check of 15 October 2026 and Scalekit's write-up of 22 June 2026. chort's facts come from its home page and repo, read on 16 November 2026.

Product Document format Agent writes with Code back out Best for
chort HTML and CSS, laid out by the browser write_html, update_styles, set_text_content, duplicate_nodes, move_nodes, delete_nodes get_jsx: JSX with inline styles or Tailwind classes A coding agent designing UI on files in a local folder
Paper MCP HTML and CSS write_html, delete_nodes get_jsx: component code An agent designing on an HTML and CSS canvas
Figma MCP server Figma's proprietary format use_figma on the remote server get_design_context, Code Connect mappings, CSS from Dev Mode Building screens already designed in Figma, or writing frames back

The three products

chort

chort is a design canvas that coding agents design on through MCP. Claude Code, Codex and any MCP client connect to it, and you watch, comment and make edits yourself. It costs $0, needs no account and has no call limits.

The document is real HTML and CSS. An agent writes a board with write_html, the HTML it already knows, then changes it with tools such as update_styles, set_text_content, duplicate_nodes, move_nodes and delete_nodes. The full tool list costs about 6k tokens of the agent's context. The set was cut down from 75,953 agent calls in one person's design sessions with similar MCP tools.

You review on the canvas. Leave comments there, and agents read the threads and mark them resolved. Every agent write is all-or-nothing and can be undone, and an agent's whole turn undoes in one step. Agents can list and restore checkpoints with list_checkpoints and restore_checkpoint. A check_design tool reports overflow, low contrast, misalignment and tiny text as text, so the agent needs fewer screenshots.

Components have one main component, and every instance follows it. Design tokens are CSS custom properties in the Tailwind v4 theme namespaces, so changing one token changes every use. get_jsx returns the JSX. Export covers PNG, JPG, WebP, SVG and PDF, plus a combined PDF and a handoff export.

Files live in a folder on your own disk, with no server and no sync. Git works on them and is the history. Screenshots and export run in headless Chrome, so agents can work without the app window open. Google Chrome must be installed. chort is a macOS app for Apple silicon, version 0.1.

Paper MCP

Paper MCP is a design tool whose canvas is HTML and CSS, with no proprietary format in the middle. According to Braintrust's eval, the agent designs by writing the same code it will ship, and reading the canvas back returns the actual CSS values on each element. A card on the canvas is already a div with CSS, and get_jsx hands it back as component code. Calls visible in the eval's traces include write_html, get_node_info, delete_nodes and get_screenshot.

Braintrust ran Paper and Figma's server in Claude Code, each agent recreating a webpage screenshot as one HTML file. Visual similarity on 40 simple pages was 0.741 for Paper and 0.744 for Figma. On 27 complex designs it was 0.716 and 0.679, a difference that does not clear significance (p = 0.21).

Per run on the complex designs, Paper took 400s and cost $2.02, while Figma took 568s and cost $2.53. Braintrust puts cost per quality point at $2.82 for Paper and $3.73 for Figma, and Figma's run-to-run variance at about 1.9 times Paper's.

Figma MCP server

The Figma MCP server gives a coding agent the frames, variables and components in your Figma files. Figma's guide says it reads live files and FigJam content, exposes tokens, variants, spacing and hierarchy, and surfaces Code Connect mappings so generated code reaches for your real components. The same connection works from Claude Code, Cursor and VS Code. Developers can push rendered UIs back into Figma as editable frames.

Braintrust describes Figma as built for humans clicking in a canvas. An agent therefore works through a translation layer, exporting code by copying CSS out of Dev Mode or by mapping components through Code Connect. Braintrust also calls the direction of an agent pushing design onto the canvas still in beta. Figma's guide lists what the server cannot do: understand why you made a design decision, or guarantee accurate code if your design system is messy.

Scalekit describes a desktop server that needs a Dev or Full seat and a remote server at mcp.figma.com/mcp that adds write-to-canvas. It says the server is in open beta, free during the beta, with Figma stating it will become a usage-based paid feature. It also says a client allowlist stops custom agent clients from connecting. Better Design's price check lists Starter at 20 tool calls a month and a Professional Dev seat at $12 a month billed annually with up to 200 tool calls a day. Confirm current terms with Figma before you commit.

Figma also ships its own design agent that works directly on the canvas. Figma's guide treats it as a different job from the MCP server.

Which one to pick

  • Pick chort if a coding agent such as Claude Code or Codex does the designing, if you want canvas comments and whole-turn undo, or if you work on an Apple silicon Mac with Google Chrome installed.
  • Pick Paper MCP if you want an HTML and CSS canvas that an independent eval has already measured against Figma's server.
  • Pick the Figma MCP server if your screens are already designed in Figma and the agent must build them as drawn, or if you want Code Connect to map generated code to your own components.

More guides