Figma has added a rulebook for AI agents to its canvas. At its first Config event in India, the company launched Figma Specs, a Markdown editor where a team writes down its design language so that people and AI agents work from the same document, according to TechCrunch. It also pushed code layers to public beta and widened its MCP server to more than 20 new tools.
The pitch is practical. As agents generate more screens and code, the problem shifts from "can it make something" to "does it follow our brand and system". Specs is Figma's answer: put the rules in a place the agent reads before it acts.
Quick answers
| Question | Answer |
|---|---|
| What launched? | Figma Specs, a Markdown editor and container on the canvas |
| Where does it live? | Standalone file or inside a canvas, per TechCrunch |
| What can it embed? | Canvas elements, FigJam diagrams, code layers, designs |
| Availability | Open beta rolling out to paid plans on web, desktop, mobile (Figma post, via a summary) |
| Agent access | Through Figma's MCP server; coding agents like Codex can read a spec |
| Also announced | Code layers in public beta; 20+ new MCP tool integrations; Payload CMS tie-in with Figma Make |
| Figma's caveat | Goal is more predictable results, not guaranteed adherence |
What Figma Specs actually is
Specs is described in Figma's launch post as a multiplayer container for Markdown-based context on the canvas, according to a summary of the post on daily.dev. Teams and agents can collaborate on product requirement documents, technical specs and design documentation in it. TechCrunch adds the design-system angle: teams can bring in design libraries, code libraries and guidelines so an agent has "centralized" context to follow.
Practical features reported so far:
- Drag in an existing .md file to turn it into a spec, then edit it collaboratively.
- Link and embed frames, FigJam files, code layers and other canvas nodes inside the document.
- Duplicate a spec so teammates can work in parallel.
- Pull in data through connectors such as GitHub and Hex, per the summary of Figma's post.
- Hand off a finished spec directly to a coding agent.
The common thread is that the spec is both readable prose and a hub of links to live design objects. That is different from a static style guide PDF: an agent that reads it can follow links to the actual components and variables.
How agents read it: the MCP server
Figma's MCP server is the bridge. According to the post summary, coding agents like Codex can read a spec along with everything it links to and act on the linked context, and an agent can update a spec as the underlying code or design changes. Figma also says MCP changes reduce errors and token usage, and that agents using it can generate images, create code layers and run Weave workflows.
TechCrunch reports that the MCP server now supports more than 20 new tools, naming Open Code, Dia, Grok Bot and the Indian AI startup Sarvam. If you already wire design context into an agent, our Figma Config 2026 recap covers the earlier June launches this builds on, and the Codex plugins repository post shows how Figma already plugs into Codex.
Code layers move to public beta
Code layers add coding to designs on the canvas for more interactive prototypes. Figma announced them in private beta in June; this week they are in public beta, per TechCrunch. Users can ask the agent to turn a design into code or change part of the code to iterate on a prototype.
Figma's chief design officer Loredana Crisan told TechCrunch: "There are 17-times more lines of code being produced today than in the past. But when you're looking at releases, only 1.3-times more releases." Her argument is that much AI-generated code is built to discover what the product should be, not to ship, which is why Figma wants the decision-making to happen on its canvas. That is a company claim about industry trends, quoted as such; we have not seen the underlying data.
Why a Markdown rulebook, and how it compares
Markdown rule files for agents are now a pattern across tools. Anthropic's Claude Design and CLAUDE.md-style files, DESIGN.md templates and Vercel's push for spec-driven UI all try to give agents persistent design context. Compare:
| Approach | Where it lives | Strength | Weakness |
|---|---|---|---|
| Figma Specs | Figma canvas | Links to live frames, variables, FigJam; multiplayer | Tied to Figma; open beta, paid plans |
| DESIGN.md | Code repo | Versioned with code; works with any agent | Cannot link to live design objects |
| Claude Design | Anthropic product | Generates designs from prompts | Different workflow; not a shared team rulebook |
See our guides to DESIGN.md templates for AI agents, Vercel's spec-driven DESIGN.md push, Claude Design from Anthropic Labs and the Impeccable design skill for the other approaches. A sensible setup is both: keep DESIGN.md in the repo for the coding agent and mirror or import it into a Figma spec so designers and agents share one source.
Who benefits most
Design-system owners get a place to encode decisions that used to live in wikis nobody read. If an agent consults the spec before generating, a rule like "never introduce a new color token" becomes something you can test rather than something you hope people remember.
Product managers and engineers can write requirement documents in the same canvas as the designs, link frames directly, and hand the whole bundle to a coding agent. That removes the copy-paste step between a PRD, a Figma file and a ticket, which is where context usually gets lost.
Agencies and multi-brand teams can keep one spec per brand and duplicate it for parallel work, then point an agent at the right one. The risk is drift: if specs multiply, you need an owner and a review habit, the same as any shared document.
Solo builders probably do not need Specs yet. If you work only in a repo with a CLAUDE.md or DESIGN.md file, the benefit of a canvas-linked document is small until you also design in Figma.
The honest limit is that a spec is only as good as its author. Vague rules produce vague output, and agents can still ignore instructions under long context. Treat the document as a living test fixture: when an agent breaks a rule, tighten the sentence and rerun.
Other announcements from the event
- Payload CMS and Figma Make. Figma acquired the open-source headless CMS Payload last year and is now integrating it with Figma Make for dynamic websites and content management. TechCrunch reports Payload downloads rose sixfold in 12 months, a figure from Figma.
- India. Figma opened its first India office late last year. The company said India is its biggest market by users outside the United States and that it works with 40% of India's top 100 Bombay Stock Exchange-listed companies. These are Figma's statements.
- Agent on canvas. In the past week Figma widened availability of its agent on canvas, per TechCrunch.
What to check before you rely on it
- Plan and availability. Reports say paid plans and open beta, and one account says it rolls out over the next few weeks. Confirm your account has it.
- Whether agents obey. Figma itself frames this as steering, not enforcement. Test with a small spec and measure how often output matches your tokens.
- Token cost. Large specs with many links can bloat agent context. Figma says MCP changes reduce token usage, but measure on your workload.
- Third-party agents. The new integrations list names several tools; check that your agent is among them and which spec features it supports.
- Data handling. Connectors to GitHub and other systems mean spec content can reach agents. Review permissions as you would any MCP tool.
For teams giving agents access to design and code systems, a runtime guard is worth considering; AgentBeam, from the explainx.ai team, is an agent security platform that stops AI agents before they take dangerous actions.
A starter spec you can try
A reasonable first spec is short and testable. Include these sections: brand principles in three bullets; spacing and type tokens linked to your variables; component usage rules ("use the existing button, never create a new one"); accessibility minimums; and a list of things the agent must never do. Then run the same prompt with and without the spec attached and compare. If the output changes in the right direction, expand. If it does not, the problem is probably vague rules, not the tool.
Bottom line
Specs is a sensible move: it gives a design-system owner somewhere to write rules that agents actually read, and it ties them to live objects rather than screenshots. The unknowns are real, mostly around pricing tiers, how reliably agents follow the rules and how it interacts with repo-based files. Treat it as a promising beta, test it on one project, and keep your repo-level rules in sync.
Details are accurate as of October 15, 2026, based on TechCrunch's report and a summary of Figma's launch post; Figma's pages are the source of truth for availability.