The usual failure mode of a design agent is that you cannot tell whether it succeeded. It emits pixels, pixels look plausible, and the argument degrades into taste. Figma Agent is the first mainstream design agent whose output lands in the same structured substrate that fed it — components, variables, auto layout — so the work is checkable by inspection rather than by opinion. That is the mechanism this review is built on: not a better prompt, but a verifiable surface.
Disclosure: this review is built from Figma’s official documentation, pricing page and published engineering posts, all read 2026-11-16, with no hands-on use. The agent entered beta on 2026-05-20, reported by TechCrunch, and went generally available on 2026-10-06, reported by FounderMag. Vendor claims are labeled as such throughout; where a third party reports a Figma claim, that is still a Figma claim.
At a Glance
Figma Agent is an AI design agent built into Figma Design, in beta from 2026-05-20 and generally available since 2026-10-06, found in the left navigation bar on all paid plans. Figma’s product page describes it as “an AI design agent built into Figma Design. It reasons, takes action, and runs multi-step design tasks on your canvas—using your real components, tokens, and variables, not placeholders.”
Four feature tiles sit under that claim: connect to a design library, parallel prompting (multiple prompts at once on one canvas), shareable threads (prompt + context + iteration history travel with the design), and skills (package workflows as reusable /commands). GA added three more: Guidelines, where library owners upload Markdown files describing how the design system should be used and the agent reads them alongside components and variables; cross-file context, pulling FigJam stickies from a workshop, copy from a Slides deck, or frames from another Design file into working context; and multiplayer agents, where collaborators follow each other’s agents on the canvas the way they follow a cursor. GA additions are documented by FounderMag and on the product page.
Availability: full seats on Professional, Organization, Enterprise and some Education plans, plus limited access on free Starter.
Pricing and credits
Credits are the meter, and they are pooled. Figma states that “Figma AI uses a credit system that is shared across all Figma AI features and products,” and that “Number of credits used varies by request.” The full ladder, from Figma’s pricing page as read 2026-11-16:
- Starter: free, unlimited drafts, 150 AI credits/day up to 500/mo.
- Professional: Full seat $16/mo + 3,000 AI credits/mo; Dev $12/mo + 500; Collab $3/mo + 500.
- Organization: Full $55/mo + 3,500; Dev $25/mo + 500; Collab $5/mo + 500.
- Enterprise: Full $90/mo + 4,250; Dev $35/mo + 500; Collab $5/mo + 500.
All Collab, Dev and View seats plus Starter users receive 500 credits/month. Extra credits are purchasable team-wide, pay-as-you-go or subscription, and Figma adds the caveat that “Included AI credits are subject to change.” Because the pool is shared across every Figma AI feature and product, agent usage competes with everything else in the file — a budgeting fact rather than a per-request price.
What It Does Best
It does best what a screenshot-only agent cannot: it writes into the same structured substrate it reads. Components stay components, variables stay variables, auto layout stays auto layout, so the result can be audited by opening the layers instead of squinting at them. Everything else — skills, guidelines, tokens — is downstream of that.
The clearest evidence is the skill layer. The foundational skill is /figma-use, and Figma published nine example skills built on it: /figma-generate-library (components from a codebase), /figma-generate-design, /create-voice (screen-reader specs from UI specs, Uber), /cc-figma-component (components from a structured JSON contract, One North), /apply-design-system (Edenspiekermann), /rad-spacing (hierarchical spacing with variables and fallbacks, Rad Collab), /edit-figma-design (Warp), /sync-figma-token (token sync with drift detection, Firebender), and /multi-agent (parallel workflows, Augment Code). Figma notes that “Anyone can author a skill and writing one doesn’t require building a plugin or writing code,” which moves behavioural control from the model to the file. The rationale is explicit: “AI models are inherently non-deterministic, so the same prompt can produce different results. Skills make that behavior more predictable by encoding specific steps, guidelines, and code to follow.” See the design-system post.
The second strength is the self-correction loop. Figma’s description of a generated screen is that it “can take a screenshot and iterate on what does not match. Because it’s working with real structure, components, variables, and auto layout, those adjustments interact with the system itself, not just the visual output.” A visual diff is not the only feedback channel; a structural one is available too. The engineering framing is consistent: “the agent needs context from the canvas and the design system, along with tools that can make the requested changes” (editing-model post).
Third, context is now addressable rather than ambient. The four named context types are Guidelines (standing rules attached to the library, “included automatically for any prompt with a library enabled”), Library examples (how components are combined in practice), Add context (a specific file or frame), and Skills (a repeatable process). The access path is agent chat → “Libraries” in the prompt box → pick the published library, with @-mention of a component or token to target it (vendor context post).
Where It Falls Short
It falls short in three places: it will not publish new assets to your shared library, its guidelines apply inconsistently when editing existing designs, and most of the quality evidence is Figma’s own.
First, the publish step is deliberately reserved for a human. Figma’s FAQ states the agent “won’t publish new assets to your shared library on its own—you’ll do that step.” Design-system governance therefore still has a manual gate, which is the right default and also a hard limit on end-to-end automation.
Second, guidelines are weaker on edits than on generation. The verbatim limitation: “Guidelines work best when the agent creates designs from scratch. We’re working to improve how consistently it applies them when editing existing designs.” If most of your workload is modifying existing screens, the feature you would most want is the one Figma says is least mature.
Third, the evidence is vendor-side. FounderMag reports Figma’s claim that the agent “wins about 60% of its internal human-graded evaluations against work from professional designers” — an internal, human-graded, Figma-run evaluation reported by a third party, not an independent benchmark. Likewise the training metrics below come from Figma’s engineering post, not from a neutral party.
If the AI Content training toggle is on, Figma “may use content and usage data to improve Figma-specific models.” And on the API side, MCP write “will be a paid API, but we’ll be offering it for free during the beta period,” so the free window is explicitly temporary (the canvas post).
Agent’s Deep Dive
Five things decide whether an agent’s work can be evaluated rather than admired: output format, exposed interfaces, canvas read and write, code round-trip, and which design signals it leaks, fixes or hides. Figma Agent answers all five concretely.
Perceive / do / verify
| Surface | Perceive | Do | Verify |
|---|---|---|---|
| Library components & variables | Reads the published library; @-mention targets a component or token |
Connects to a design library and builds with it | Layers retain component instances; token names stay exact |
| Design guidelines | Reads Markdown files uploaded by library owners | Applies them when generating from scratch | Stated limitation: less consistent when editing existing designs |
| Canvas pixels | Screenshot of the current selection | Multi-step visual edits | The agent re-reads a screenshot and iterates on mismatches |
| Canvas structure | Code representation plus variable definitions carrying code syntax | Edits components, variables, auto layout | Deterministic structural checks run before visual judges |
| Tokens & patterns | Exact token name and Code Connect path, not a color match | Token sync skill with drift detection | Drift flagged against the source of truth |
| External code | React + Tailwind representation of a selection | generate_figma_design turns HTML into editable layers |
Code Layers open beta since 2026-10-23 (Specs, Code Layers and Payload announced 2026-10-16) |
| Cross-file context | FigJam stickies, Slides copy, frames from other Design files | Pulls them into working context | Thread history travels with the design |
| Shared library | — | Explicitly does not publish new assets | You do that step |
(a) Machine-readable output format
The output format is code-shaped, not image-shaped. The MCP server exposes a code tool whose response type is configurable; it can return a working React + Tailwind representation of the current selection. Variable definitions are handed over with code syntax attached, and pattern metadata means the server delivers the exact Code Connect path and the exact token name rather than an approximation. Figma’s illustration is the sharpest statement of the point: “if you take a screenshot of a red rectangle and prompt your agentic tool to use tokens, there might be many different tokens with the same red value. Figma knows which specific token is used.” A screenshot cannot disambiguate; a structured read can (MCP server post).
(b) MCP/CLI exposure
On the read side the MCP server offers context tools: code, a screenshot of the current selection, and variable definitions with code syntax. On the write side, the 2026-03-24 release added use_figma, through which “Claude Code, Codex, and other MCP clients can generate and modify design assets that are linked to your design system.” The earlier generate_figma_design translates HTML from live apps and websites into editable Figma layers; Figma presents the two as complementary — bring code UI in, then edit or extend it with your components and variables.
The listed MCP clients are Augment, Claude Code, Codex, Copilot CLI, Copilot in VS Code, Cursor, Factory, Firebender and Warp. The roadmap states Figma is “working toward parity with the Plugin API, starting with image support and custom fonts,” with reachable surfaces including Code Connect, Figma Draw, and FigJam through the Plugin API (the canvas post). Write access is free during the beta period with a paid API planned.
(c) Canvas read + write capability
Read capability runs at three depths: pixels (screenshot of the current selection), structure (code representation and variable definitions with syntax), and semantics (the exact token and Code Connect path). Write capability runs through use_figma for generating and modifying design-system-linked assets, plus the in-canvas agent itself, which operates directly on the open canvas with multi-step tasks, parallel prompting, and shareable threads.
The feedback loop closes the circuit: generate, screenshot, compare, adjust — with the adjustment landing in real structure, per Figma’s own description that changes “interact with the system itself, not just the visual output.” Two guardrails bound the write side. The agent “won’t publish new assets to your shared library on its own—you’ll do that step,” and MCP write is slated to become a paid API. Multiplayer agents add a social read: collaborators follow another person’s agent on the canvas the way they follow a cursor (FounderMag).
(d) Code round-trip
The round trip has three legs. Inbound: generate_figma_design converts HTML from live apps and websites into editable Figma layers, so existing product UI becomes something the agent can extend with real components and variables. Outbound: the MCP code tool can return a working React + Tailwind representation of the selection. Middle: Figma Specs, Code Layers and Payload were announced at Config India on 2026-10-16, with code layers entering open beta on 2026-10-23.
The claim is not that code and design are identical, but that each direction carries machine-readable meaning — syntax on the way out, layer structure on the way in, with Code Connect mapping components to their code paths. That is what makes a round trip checkable on both ends instead of a lossy export (product page).
(e) Design signals leaked, fixed, and hidden
Leaked: exact token names, Code Connect paths, variable definitions with code syntax, component identity, auto layout parameters. These are signals a raster-only agent never sees, and they are what let a reviewer confirm that a red rectangle is bound to the intended token rather than a lookalike.
Fixed: deterministic validators plus visual model judges check candidates for valid output and request fulfilment, the pipeline can self-heal from evaluator feedback, and evals combine structural checks with visual judges calibrated by expert designers. Figma reports internal results of 77.8% for Figma design edits v3 versus 76.9% for Sol 6.1, and states the latest unreleased editing model is post-trained on Qwen 3.8 27B. Skills fix behaviour the same way at inference time, by encoding steps instead of trusting the prompt.
Hidden: per-request credit consumption is unpublished (“Number of credits used varies by request”), the human-graded 60% figure is internal, and the training data path depends on the AI Content toggle. Beta-to-GA deltas are vendor-reported: typical tasks ~20% faster, beating or matching the previous production agent 62% of the time in head-to-head testing with expert designers, user ratings 33% higher, and users undoing the agent’s work 60% less often (editing-model post).
How We Tested
This review is built from Figma’s official documentation, pricing page and published engineering posts, all read 2026-11-16, with no hands-on use. Nothing here claims a run, a session, or an observed latency: every figure is quoted from a page and attributed to it.
Method: read the product page for capabilities and FAQ, the pricing page for the credit ladder, and three engineering/blog posts for mechanism — the MCP server post, the canvas post, the design-system post, and the editing-model post. Timeline was cross-checked against TechCrunch for the 2026-05-20 beta and FounderMag for the 2026-10-06 GA.
Claim provenance: capabilities, pricing, credits, eval percentages, GA deltas and the 60% figure are vendor claims — the last is Figma’s internal human-graded evaluation as reported by FounderMag, not an independent measurement. Independent corroboration here is limited to the two launch reports confirming dates and availability tiers; no third party has published a controlled comparison. Treat every percentage in this post as Figma’s number.
The Bottom Line
Verdict: Figma Agent is the first mainstream design agent whose output is checkable by inspection, because it writes back into components, variables and auto layout rather than emitting pixels. That makes it genuinely useful to teams with a real design system, and still bounded where publishing, guideline consistency on edits, credit cost, and independent evidence are concerned.
For a team evaluating it, the practical reading is narrow. If you have published libraries, token names, Code Connect mappings and Markdown guidelines, the agent inherits your system and its output can be audited structurally. If you do not, the verifiable surface does not exist, and you are back to judging screenshots. The self-correction loop only pays off when “what does not match” can be checked against structure.
The unresolved questions are the ones no vendor page answers: how credits actually consume per request, what the agent does on a messy legacy file with no library, and whether an independent party can reproduce the 60% internal figure. Until those are settled, the honest position is that Figma Agent demonstrates the mechanism this blog is after — a verifiable surface for agent output — without yet proving the outcome. Related reading on the substrate itself: The Figma agent is here.
FAQ
These are the questions that change a buying or integration decision. Each answer comes from Figma’s own pages, read 2026-11-16, with no hands-on use.
What does Figma Agent cost, and how do credits work?
Starter is free with unlimited drafts and 150 AI credits/day up to 500/mo. Professional is Full $16/mo + 3,000 credits, Dev $12 + 500, Collab $3 + 500. Organization is Full $55 + 3,500, Dev $25 + 500, Collab $5 + 500. Enterprise is Full $90 + 4,250, Dev $35 + 500, Collab $5 + 500. Credits are shared across all Figma AI features and products; “Number of credits used varies by request” and “Included AI credits are subject to change.”
Will it publish to our shared library?
No. Figma’s FAQ states the agent “won’t publish new assets to your shared library on its own—you’ll do that step.” Publishing stays a human action, so the agent can generate library-ready work without mutating the system of record.
What can an external tool reach through MCP?
The read side exposes a code tool (optionally returning React + Tailwind), a screenshot of the current selection, and variable definitions carrying code syntax, plus exact token names and Code Connect paths. The write side is use_figma for design-system-linked assets and generate_figma_design for HTML-to-layers; write is free during the beta period with a paid API planned, and Figma is “working toward parity with the Plugin API, starting with image support and custom fonts.”
Does it work well when editing existing designs?
Less well than when generating. Figma’s verbatim limitation: “Guidelines work best when the agent creates designs from scratch. We’re working to improve how consistently it applies them when editing existing designs.” Cross-file context and @-mention targeting help, but guideline adherence on edits is the acknowledged weak spot.
Is my content used to train models?
It depends on a setting. If the AI Content training toggle is on, Figma “may use content and usage data to improve Figma-specific models.” Teams with confidentiality requirements should audit that toggle before enabling the agent on client files.
