# The Flash plugin or the Figma agent? Use the one that fits the moment

> Two ways to get your Flash system into Figma. The plugin builds the whole file and keeps it following; the agent does it from a sentence. They write the same thing.

- Source: https://flashdsm.com/blog/figma-plugin-or-figma-agent
- Published: 2026-09-24
- Author: Flash DSM Team
- Track: Notes
- Reading time: 4 min read

---

## Two doors into the same file

Flash now reaches Figma two ways. The [Flash plugin](/blog/figma-plugin-live-sync) runs in a panel you open in a file. The [Figma agent connector](/blog/figma-agent-build-variables) lets Figma's own AI agent call Flash from its chat. People ask which one they should use, and the honest answer is that they are not rivals. They were built so a file made by one looks exactly like a file made by the other, and you will likely use both.

The short version:

| | The plugin | The Figma agent |
| --- | --- | --- |
| How you start it | Open the Flash panel and click Build | Type what you want in the agent's chat |
| What it builds | Variables, styles, and Foundations, Components, Icons and Modules pages | Variables, modes, aliases and text styles |
| Keeps following Flash | Live sync, while the panel is open | When you ask it to sync again |
| Sends changes back | Push, into Sync > Review | push_figma_variables, into Sync > Review |
| Signs in with | A one-time pairing code | Flash's OAuth consent screen |
| Figma plan | Any plan | A plan with the agent and a Full seat |
| Flash plan | Pro and up | Any Flash plan |

## Why they never disagree

The rules for turning a design system into Figma variables are fiddly. Which collection a colour lives in. That the modes are called Dark and Light. That a semantic colour is an alias into the ladder in the same collection, per mode, because `background` points at a dark step in one theme and a light step in the other. That a token Flash renamed should be renamed in the file, not duplicated. That nothing Flash does not know about gets deleted.

All of that lives in one place, the plugin's planner. When the Figma agent asks Flash what the file should hold, Flash runs that same planner and hands the agent its answer, page by page, in the shapes Figma's own API uses. The agent does the typing; the decisions are the plugin's. So if you build a file with the agent on Monday and a colleague runs the plugin's live sync on Tuesday, nothing moves, because nothing is different.

## When the plugin is the better tool

**The first build of a real library.** The plugin draws the whole file, not just the variables: a cover, a Foundations page with your colour ramps and type scale, every component as a variant set with its states, icons as components, and your modules. Flash hands the agent the variables and text styles, which is what most day-to-day work needs; the pages are the plugin's job.

**A file that should follow Flash all afternoon.** Live sync polls Flash on an interval while the panel is open and applies each change as it lands. The agent syncs when you ask.

**A team without the Figma agent.** The plugin runs on any Figma plan and any seat that can run plugins. The agent needs a paid plan and a Full seat.

## When the agent is the better tool

**You are already in the chat.** If a designer is asking the agent to lay out a screen, "pull the latest tokens from Flash first" is one more sentence, not a context switch into a panel.

**You want to ask before you touch.** "How many colour variables does Flash have, and which ones are missing from this file?" is a question the agent can answer from the plan and the file together, without writing anything.

**Many files, one routine.** A prompt you trust is easy to repeat in every file of a project. Combined with **Always run** on the read tools, keeping a dozen files current becomes a sentence each.

## Using both

This is the setup we would start with. The plugin builds the library file once, pages and all. Product files get their variables from the agent when someone starts a new one, and designers push edits back from whichever tool they happen to have open. Every push, from either door, lands in [[Sync > Review]] and waits for a person, and both leave a record of which version they wrote, so the Sync page can tell you which files are behind.

If you work in code rather than in Figma, there is a third door: Claude Code, Cursor and Codex can hold Figma's own MCP server and Flash's at once, and the Figma sync skill under [[Sync > Agents]] gives them the same planner and the same rules. The [MCP guide](/mcp) covers connecting Flash to any of them.

## The one thing that is the same everywhere

Flash stays the source of truth. The plugin, the agent and the code agents all read your system when they need it instead of keeping a copy, and none of them can change it without someone saying yes. Pick the door that fits the moment; the room behind it is the same.