Skip to main content
Glama

figlens turns saved Figma files into design context your coding agent can act on—not just a screenshot to interpret.

  • Build from the source details. Read layout, text, styles, variables, Dev Mode annotations and Ready for dev status; export vector icons as SVG and images as assets. bundle collects a frame's data, assets and reference render; verify reports missing files, font checks and handoff limitations. MCP nodes can save large node JSON to a file with out instead of returning it inline.

  • Compare the running UI. compare-image compares your screenshot with figlens's render and names the layers under differing regions. Review those differences and rendering warnings; it is not a pixel-perfect guarantee.

  • Follow design changes. diff compares saved revisions; changes and watch report updates to tracked local scopes; freshness tells when a saved copy is older than the online file, and pull saves a new copy through your own browser sign-in. Save a new .fig from Figma to pick up design edits—this is not live Figma sync. Named accounts route each design to separate browser profiles and API-token environment variables; existing defaults stay unchanged. figlens sources init [DIR]: Scan local .fig files into .figlens/sources.json without overwriting it; names come from meta.json or the filename. Fill in the blank URLs before pulling.

Offline at the foundation. In Figma, File > Save local copy. Put design.fig next to your code. Then a Figma link is enough: its node id picks the frame. With no saved copy, copy the layers in Figma (right-click > Copy) and run figlens clipboard screen.fig; a copy has no images or vector outlines (how). One native binary reads it locally, without a running Figma app, login or network calls to Figma; only the opt-in freshness check (with a configured API token; default: FIGMA_TOKEN) and pull (through your browser sign-in) reach Figma.

Get started

No design file yet? Check your setup with the tiny public example: verify your chosen binary, find one frame and validate its bundle. No model required.

Put design.fig in your project, then choose one setup. Each gives your agent the figlens tools and the same built-in guidance for planning, implementation and image preparation.

Setup

Use it for

Guidance comes from

Plugin

Claude Code, Codex, Antigravity, Cursor, Kimi Code

the plugin's skill and the server's workflow tool

MCP

Claude Code, Cursor, Codex, Gemini CLI and other MCP clients

the server's workflow tool

Pi

Pi 1.3.0+

the package, which ships the skill

OpenCode V2

OpenCode V2 2.2.0

the package skill

OMP

OMP 18.13.2

the package skill

Herdr

a panel beside your agents in Herdr 0.1.12+: find a screen, hand it to one, track each screen's progress on a board

the receiving agent's own setup

CLI

agents that only run shell commands, scripts and CI, or you

figlens workflow <topic>, or the optional skill

Ordinary vs advanced. Ordinary use needs no setup: figlens search design.fig "query" reads the .fig and creates nothing. An optional local index is created only when you ask for one (figlens index prepare design.fig --scope 0:0), then reused across restarts and hosts. See Ordinary search and the optional local index. Optional and experimental: --mode semantic or hybrid ranks by meaning with a local model you set up yourself; see Optional semantic search.

Plugin

One install adds the figlens skill and MCP server to your agent (Node.js 18+). The server is pinned to the plugin's release (npx -y @runkids/figlens@<version> mcp); update the plugin to move to a new version.

Host

Install

Claude Code

claude plugin marketplace add runkids/figlens, claude plugin install figlens@figlens

Codex

codex plugin marketplace add runkids/figlens, codex plugin add figlens@figlens

Antigravity

agy plugin install https://github.com/runkids/figlens/tree/main

Cursor

git clone --depth 1 https://github.com/runkids/figlens ~/.cursor/plugins/local/figlens, then reload the window

Kimi Code

/plugins install https://github.com/runkids/figlens/tree/main in a session, then /reload

skillshare installs the same plugin on several hosts at once: skillshare plugin add https://github.com/runkids/figlens.git --target claude --target codex --target cursor -g; update it later with skillshare plugin update figlens -g.

Restart the host or start a new session, then check that the figlens tools are listed. A plugin install copies the repository: about 7 MB, plus the Git history (about 60 MB) in Codex. Antigravity loads only the first 24 KB of the skill; the server's workflow tool serves the full guidance. Muse is not supported yet. Host matrix and what was verified

MCP

Claude Code (Node.js 18+, macOS/Linux):

claude mcp add --transport stdio --scope local figlens -- npx -y @runkids/figlens mcp

Codex CLI (Node.js 18+, macOS/Linux):

codex mcp add figlens -- npx -y @runkids/figlens mcp

Any MCP client:

{
  "mcpServers": {
    "figlens": {
      "command": "npx",
      "args": ["-y", "@runkids/figlens", "mcp"]
    }
  }
}

Without Node.js, install the standalone binary (CLI) and use "command": "figlens", "args": ["mcp"]. Start a new session and check that the figlens tools are listed (/mcp in Claude Code). No separate skill install is required. Add --root <dir> after mcp to limit which folders figlens may read and write.

MCP startup arguments

Add these options after mcp in your client's args. These are the only MCP startup options; both are optional and repeatable.

Option

Meaning

--root DIR

Allows design reads and exports inside DIR and its subfolders. Without it, figlens adds no path restriction: OS permissions still apply. It does not default to the current project or scan the computer.

--storage-root DIR

Allows explicitly requested custom index storage inside DIR and its subfolders. It does not select or change the default storage location.

Use absolute paths to existing directories. Each option and path is a separate array item; repeat the option for multiple folders. --root means a path boundary, not administrator access, and only restricts figlens MCP, not the agent's other tools.

Example with two design/output roots and two allowed storage roots:

{
  "mcpServers": {
    "figlens": {
      "command": "npx",
      "args": [
        "-y", "@runkids/figlens", "mcp",
        "--root", "/absolute/designs",
        "--root", "/absolute/project",
        "--storage-root", "/absolute/storage-a",
        "--storage-root", "/absolute/storage-b"
      ]
    }
  }
}

There is no figlens mcp --storage option. Choose the actual location with the index tool's storage argument (an absolute path under an allowed storage root), or CLI figlens index prepare design.fig --storage /absolute/storage-a. After prepare, figlens remembers that workspace's location and reuses it across restarts and hosts without repeating storage or --storage-root. Without a custom location, the per-user defaults apply; no storage flag is needed.

To keep these paths out of a checked-in config, or to share designs across Git worktrees, see roots in a checked-in config.

Multiple storage roots only expand the allowed locations: each storage argument still selects one location. They do not distribute, sync or back up indexes. An existing workspace database cannot be moved by simply naming another root; figlens refuses the conflicting location.

Pi

One package ships the CLI, MCP, viewer, /figlens commands and skill:

pi install npm:@runkids/figlens

Pi extension guide

OpenCode V2

Install the package in OpenCode V2:

opencode plugin add @runkids/figlens

Restart the host, then run /figlens help. OpenCode V2

OMP

Install the same package in OMP:

omp plugin install @runkids/figlens

Restart the host, then run /figlens help. OMP

CLI

Run it through npm, or install the standalone binary:

npx @runkids/figlens --help                                                                # Node.js 18+, no install
curl -fsSL https://raw.githubusercontent.com/runkids/figlens/main/scripts/install.sh | sh  # macOS, Linux
brew install runkids/tap/figlens                                                           # Homebrew
irm https://raw.githubusercontent.com/runkids/figlens/main/scripts/install.ps1 | iex      # Windows PowerShell

npx runs the binary of the package version it resolves. Script installs update with figlens update; Homebrew installs with brew upgrade figlens. Binaries cover macOS (Apple silicon, Intel), Linux (arm64, x86_64) and Windows (x86_64).

An agent that uses the CLI reads its guidance with figlens workflow build (also audit, images, search, plan, planning-details and the opt-in yolo), which always matches the binary's version, or from the agent skill.

CLI reference

Different Figma accounts can use figlens pull --login --account work and optional "account": "work" in the source mapping. Existing default sessions need no migration. Figma accounts: browser login and API tokens.

figlens sources init [DIR]: Scan local .fig files into .figlens/sources.json without overwriting it; names come from meta.json or the filename. Fill in the blank URLs before pulling.

Agent skill (optional)

The skill teaches an agent the same workflow as the built-in guidance: find the frame, read the bundle in small pieces, plan scoped work and check the running UI against the design. It holds instructions only, so pair it with the CLI or MCP. MCP and Pi setups do not need it.

Recommended: skillshare. Install the skill once and sync it to each agent you use:

skillshare install github.com/runkids/figlens/skills/figlens
skillshare sync

The same tool can also set up the figlens MCP connection for those agents:

skillshare mcp add figlens --global --target claude --target codex --target cursor --no-tui -- npx -y @runkids/figlens mcp
skillshare sync mcp --global

Other ways to install the skill:

npx skills add runkids/figlens --skill figlens   # Skills CLI

Or copy skills/figlens/ from this repository or a release archive into your agent's skills directory (Claude Code: ~/.claude/skills/). An installed skill updates separately from the binary; figlens workflow always matches it.

Then ask for a screen:

Build the task board from ./design.fig in this project.
Find the matching frame, use this project's components and image workflow,
then compare the running UI with the design and fix confirmed differences.
Report missing assets and any checks you could not run.

The agent finds the frame, bundles its design data, assets and reference image, then builds the screen with your stack. The shared workflow guides font and asset checks; missing inputs are reported while layout implementation continues with documented fallbacks. Ask for the changed files and a browser comparison.

Related MCP server: FreeMCP for Figma

Demo: Pi builds a React screen from a .fig

Pi plans from a local .fig, builds a React screen and checks it beside a live browser

Looping GIF at 3× the edited video’s playback speed. Click it for the full 78-second video.

78-second video. Pi runs /figlens plan, reads a dashboard frame from a local .fig, builds it with React and Tailwind CSS, then checks and corrects the running UI. Edited time-lapse, not a benchmark or a pixel-perfect promise. Design: Task Flow by Eymen Eid · recording notes.

From .fig to editable HTML/CSS: in a controlled task-list study, all six figlens-based attempts preserved all 19 visible text occurrences as real DOM text and all four icons. CLI and MCP extraction also passed with Docker networking disabled. Follow the case study for setup, measurements and independent image comparisons.

Why figlens instead of the official Figma MCP?

Use figlens when the design should travel as a file: remote agents, CI, offline work, handoff between agents, unlimited repeated reads. Use the official Figma MCP when the agent must see the live design without an export step.

Reading a .fig is offline. Installing and updating figlens, gs:// inputs, the opt-in freshness check and pull, your model provider and your project's dependencies still need a network.

Full comparison

What the agent gets

One frame, one zip. Structure to build from, assets to use, a picture to check against.

Bundle contents and examples · How close is it to Figma?

Documentation

Limitations

  • Snapshots, not live sync. Export a new .fig when the design changes. figlens cannot download a design from a Figma URL.

  • Undocumented format. figlens decodes the file's embedded schema; new Figma exports may need a figlens update.

  • Fonts and text: font files are not bundled; overridden text can retain Figma's saved layout. Use licensed project fonts and compare the result.

  • Support coverage: follow rendering improvements and handoff semantics in the issue tracker. See current semantic coverage.

  • Check the output. Read bundle warnings, missing-assets.json and unresolved variables in context.md, then compare the implementation with the design.

  • Known visible rendering limitations appear in node _figlens.renderDiagnostics, bounded inspect summaries and bundle and export warnings; missing-assets.json lists only asset failures. No warnings does not establish pixel fidelity. A background blur past the 64 one export draws is left out and named only in those warnings (20 nodes, then a count).

Help figlens grow

If figlens turned a design into code for you, star the repo so others find it. Hit a file it cannot read? Open an issue with the command and what you expected.

Development runs Rust in Docker only: docker compose run --rm dev cargo test. See AGENTS.md and the wiki.

License

MIT. figlens is an independent project, not affiliated with, endorsed by or sponsored by Figma. The .fig format is undocumented and may change; use only files and assets you have permission to access and share.

Available Tools

20 tools
bundleA

Write a design bundle zip for one node or exact instance sublayer: nodes, variables, assets, reference render, context.md. When the user requests related component states, pass states=true to include their explicit variants and evidence gaps.

Inputs: out (required), file (required), node (required), name, +3 more. Returns: path, nodeId, warnings

changesB
Read-only

Recorded design changes of the scopes index track follows; never writes or builds. A query subscription's subscriptionId instead pages its stored search evaluations (evaluations, evaluation, tracking; no revision pages); ack them the same way. Its evaluation is current, current_for_index (the file changed or is gone since that index: refresh, then evaluate), pending with an evaluate step, or unavailable (also when its last evaluate at this publication failed, with that reason, until a later publication); a stored evaluation too large or damaged to page fails with a recovery that acks past it. Each revision is one published build of a tracked scope: kind baseline (tracking started, or nothing comparable before it, with a reason: tracking_started, tracking_changed, previous_changed, previous_untracked, previous_unpublished, facet_version_changed, or index_version_changed when the previous build used other index versions, such as relations before library references) or changes, with coverage, exact summary counts per change kind and facet, and detail complete, truncated or expired. A changes revision's impact says which layers its changes reach: complete, reasons with counts (impact_truncated: layers left out of its detail) and listed, the count per class (direct, effective, effective_unchanged, possible; a class judges the layer's own fields, not its children, which have their own changes) of the layers its detail listed when recorded, never a total (an expired detail no longer keeps them); it is null for a baseline or a revision recorded before impact, never an empty complete one. A node subscription also reads revisions whose changes reach that layer or a layer of that top-level frame, or whose impact is incomplete. Pages run oldest first after cursor, else after the consumer's checkpoint (moved by watch ack), else from the oldest kept. Pass revision to page that revision's changed nodes, then the layers its impact lists, instead; each entry's entry field says which (change or impact). tracking lists each tracked scope's state, lastRevisionId and refreshRequired (the file changed since its last build: refresh the scope to record it; an empty page never proves the file unchanged); monitor is the watch monitor, separate from tracking. A cursor is bound to the filters, the visible sources and the workspace incarnation: any other use is cursor_stale. event_gap means retention deleted revisions before they were read: follow its recovery and treat the scope as possibly changed.

Inputs: workspaceId (required), limit, scope, cursor, +5 more. Returns: nodes, detail, hasMore, monitor, +9 more

compare_imageA

Compare a PNG screenshot of the built screen with the node as figlens renders it, to check visual fidelity with a tool instead of by eye. The node is drawn over its layout box at the screenshot's scale (screenshot width / node width, or scale), composited over white; a pixel differs when no pixel within one CSS pixel in the other image is within the threshold (48/255 per channel by default), so anti-aliasing does not count, but differences under it (light borders, subtle tints) are not seen. Differing pixels are grouped into regions on an 8 px grid; regions under 12 px² are dropped. Returns sizes, scale, mismatch (differing pixels / compared pixels), nonTextMismatch and textMismatch, nonImageMismatch and imageMismatch, and the largest regions in node pixels from its top-left, each with the deepest layers under it (id, name, type) and text: true when nearly all of it lies over TEXT layers (often font fallback or line breaks, but also a wrong text color, size or copy: review each) and image: true when nearly all of it lies only over image-filled layers (content such as banners or avatars, often from data). ignore leaves listed layers' render boxes out of every count and region, for content that differs by data rather than layout (their own size and position are then unmeasured); the reply lists them. threshold lowers the 48 default to see light borders and dividers, at the cost of more anti-aliasing noise. A screenshot taller than the node is compared over the node's height and the rest reported as uncompared; a shorter one, or a width that does not match scale, is refused, unless fullPage states the shorter one is the whole page: then its rows are compared and the node rows it lacks (past 1 px rounding) are reported as uncompared.missing and counted as one differing region over the layers there. warnings name what figlens skipped or approximated in the node, where a difference may be figlens's. out writes a diff PNG: the screenshot washed out, differing pixels red, ignored pixels gray, regions outlined red (layout), blue (text) or purple (image). Capture the screenshot at the node's size with fonts loaded; a viewport capture of a taller page needs a full-page screenshot.

Inputs: file (required), node (required), image (required), out, +5 more. Returns: node, path, frame, scale, +14 more

diffA

What changed between two saved revisions of a design (old, file): exact layer ids and types only: a frame renamed in place (same id and type) is a structure change, while a recreated frame (a new id) is reported as removed plus added, with a labelled possibleMatch (same name, else same rounded size and position) that never claims identity; lineage between the two files is not verified. Each changed top-level frame (layers directly on a page group under the page) has one summary line with counts per facet: text (text, fonts and laid-out glyphs), layout (size, transform, constraints, auto layout), appearance (fills, strokes, effects, opacity, radius, visibility), properties (component property definitions and assignments, variable values, scopes and code syntax, descriptions, style type, Dev Mode annotations and categories, a page's Ready for dev map and prototype interactions), structure (name, type, parent, order, hidden) and bindings (variable, style, image, main component and prototype edges, old and new compared so removed ones are listed). Nodes carry changed fields with old/new values (each within 512 bytes and 4 KiB per node, 256 KiB per page; larger values say truncated, never unchanged) and edge additions/removals, with swap naming both mains. A side that stopped short reports its missing layers as unknown, never removed; a layer with a field it could not read and no proven difference is unknown with unread, never changed. Pages of changes in stable frame order; nextCursor binds both snapshots, the node, the built corpora and the retained result, so a rebuild that stopped elsewhere is cursor_stale. Nothing is written.

Inputs: old (required), file (required), node, limit, +1 more. Returns: node, frames, source, coverage, +2 more

exportA

Export a node to SVG, PNG, JPG, WebP or AVIF. Create the output directory first. Returns metadata and, for raster formats, an inline image. PNG suits inline references: up to 4,194,304 pixels it is losslessly optimized with exact decoded RGBA, keeping original encoded bytes unless smaller; larger PNGs keep regular encoding. For website assets, follow the target project's existing image pipeline; otherwise start with WebP for bitmaps, sized for display dimensions and DPR using scale/maxSize and quality/maxKb. SVG embeds original images and can be large; keep it for vector artwork. When inlining or optimizing SVG, keep its root transform and unique ids (SVGO: prefixIds, not cleanupIds). The export covers what the node draws; bounds: layout exports the layout box, and warnings report when the two differ, any known skipped or approximated rendering in the subtree, as bundle warnings do, and images or components the file lacks. scale, quality and maxSize affect raster formats only; maxSize defaults to 1600. Check returned dimensions/bytes and isError; read content on failure.

Inputs: out (required), file (required), node (required), hide, +6 more. Returns: path, bytes, width, height, +7 more

export_batchA

Export many nodes of one file in a single call, one file per item; use it instead of repeated export calls for a screen's icons and photos. Each item takes the options export takes (node, out, bounds, scale, quality, maxKb, maxSize, hide; the format follows out's extension) except matchDir. Create the output directories first. At most 64 items, distinct out paths, all inside the configured roots; a malformed item or a path outside the roots fails the whole call before anything is written. Items then export in order: one that fails (a missing or hidden node, a file over maxKb) is reported with its error and the others still export, so check each entry's error. Returns a manifest, no inline images: per item node, path, width, height, bytes, quality, layoutBox, renderBox and warnings, or node, path and error; warnings say when the drawn area reaches past the layout box (a badge or shadow), as export's do. Once the files written reach 256 MiB, the remaining items fail with a budget error; export them in another call.

Inputs: file (required), items (required). Returns: count, items, failed

findA

Search stored layer names and text (case-insensitive). Returns ids, paths, local sizes and text previews. Does not expand instance children; use inspect on the instance. Copy inside instance overrides, text or boolean properties or swapped components is found by search, not find.

Inputs: file (required), query (required), node, type, +1 more. Returns: root, results, freshness, truncated

freshnessA
Read-only

Tell whether saved .fig copies are older than their online Figma files, before concluding a design lacks a frame: the designs in a mapping (a JSON list of {name, url, file}, file relative to the project root for .figlens/sources.json, else to the mapping's folder), one file found in the nearest .figlens/sources.json at or above it, or one file with its url. Saved time is exported_at in the copy's meta.json; online time is last_touched_at from Figma's REST file metadata, read with an environment token (never an argument or output). The optional account overrides the mapping's account; named accounts resolve tokenEnv in the server user's figlens config/accounts.json, and unnamed entries keep FIGMA_TOKEN. Missing named config/token never falls back. Per-design account/tokenVar/tokenSet describe named routes; top-level tokenVar/tokenSet describe only default FIGMA_TOKEN. Each design is stale, current or unknown with a reason (no_token, account_not_configured, account_config_invalid, no_saved_time, not_mapped, file_missing, url_unrecognized, offline, token_rejected, file_not_found, rate_limited, curl_unavailable, outside_roots, unexpected_response, token_invalid, deadline when a listing ran out of its 60 s, cancelled). A stale copy needs the user to save a new local copy (File > Save local copy); nothing is downloaded. With a token, a node not found or an empty find in a mapped stale copy carries the same hint.

Inputs: url, file, account, sources. Returns: designs, mapping, tokenSet, tokenVar

indexA
Destructive

Local workspace indexes for search: prepare registers a .fig (file) in its own workspace, or in a project workspace (workspace: a project directory), and with scope starts a background build of exactly that stored scope; status reports sources, indexed scopes and storage; add, remove and relocate change the registered sources (remove withdraws their indexes; add of a directory registers up to 10 .fig files under it in one step, in path order, never through a link leading out of it, and replies directory {added, existing, skipped, notFig, truncated, nextCursor}; pass nextCursor as cursor to add the next 10; a repeat adds nothing, and a moved file is a new source unless relocated); refresh rebuilds changed scopes and rebuild every indexed scope even when unchanged (sourceId and scope narrow both), while the previous index keeps serving; track starts recording one scope's changes, read with the changes tool, with a baseline build, and untrack stops it, keeping its history; embed runs the configured local model (models tool) over published scopes for semantic search, as jobs beside the text builds (mode_unavailable without a profile), and a text build this server runs queues it after publishing; visual (scope required, never widened to the whole file) renders that published scope's screens and components, and the scope node below a page, for image search, and embeds them when a vision profile is configured (hash-only otherwise), as a job on the model lane beside text builds; called again it resumes a partial layer, retrying units that failed; a scope that had a visual layer is rendered again after a text build this server runs republishes it, and no other scope is rendered implicitly; a reply that could not admit every job has admission partial and deferred items, each with the nextStep that builds it later; clear_cache deletes only what a build can recreate; reset deletes this workspace's database after the user confirmed it, keeping every .fig and export. Builds run as jobs: the reply has job {jobId, state}; poll the jobs tool, cancel there. Nothing is built implicitly: connecting, listing, find, inspect and file search create no database. Errors carry _meta.figlens.recovery with only the actions that apply; recreate_elsewhere and reset need the user's confirmation.

Inputs: action (required), file, scope, cursor, +6 more. Returns: job, jobs, paths, state, +12 more

inspectA

Compact expanded node summary with path, the node's ancestors from the document down ([{id, name}] as in find; for a layer, path[1] is its page), so a pasted link's screen needs no find: bounds, layout, typography, text previews (fullText=true for complete text), Dev Mode annotation label previews and Ready for dev devStatus, and child counts. colors=true adds resolved solid fill colors with bound variables; other paints stay in nodes. A parent without auto-layout has childSpacing "derived": gaps between its children are coordinate differences, not an auto-layout rule; constraints may still pin them. For image decisions, images=true adds original dimensions/bytes and source-pixel rectangles before masks, not blur diagnoses. Depth and a 200-node budget bound the summary; image paints have their own 200-item limit. nodes returns full design data.

Inputs: file (required), node (required), flat, depth, +6 more. Returns: flat, node, path, images, +7 more

jobsA

Status or cancellation of an index job. status reports state (queued, running, succeeded, failed, cancelled, interrupted), stage, progress and the error or published generation; cancel stops the build and its worker process before reporting cancelled, and a job already publishing finishes (too_late). Responds while builds and searches run.

Inputs: jobId (required), action (required), storage. Returns: kind, error, jobId, stage, +6 more

modelsA
Destructive

Local model profiles: bge-m3 (text) for semantic and hybrid search, and siglip-base (image) for search with image or imageRef. list shows the documented profiles with modality, model, revision, license and the files each needs; status reports each configured profile ready or unavailable with the reason, and the setup steps for each modality no profile serves; configure checks a model directory the user already downloaded against pinned SHA-256 digests, starts the figlens-embed shipped beside figlens once offline and records the profile; remove forgets the profile and keeps its files. Nothing is downloaded and no design content leaves the machine.

Inputs: action (required), profile, modelDir. Returns: setup, removed, profiles, configRoot, +2 more

nodesA

A node or exact instance sublayer as the per-node object of a Figma REST nodes response ({document, components, componentSets, styles, schemaVersion, _figlens}; _figlens.semantics.verification covers every node's _figlens.semantics): instances expanded, fills, strokes, effects, full text, auto-layout, masks, component data, Dev Mode annotations with labelMarkdown (named annotationCategories at the top level) and devStatus. Use it when inspect's compact summary lacks paints, masks or full text. A whole screen is often hundreds of KB, and agent hosts may show only part of a reply over about 20 KB, so read a screen with out, then query that file with jq or read it in parts; or scope to a smaller node, use inspect (flat for an outline), or write a bundle. Without out, replies over the MCP reply budget fail with response_budget_exceeded; with out, only a selection that outgrows that budget while being built does. Opt-in compact shares styles, and subtrees additionally shares templates; resolve the versioned references before passing to REST consumers. The reply budget applies to the compact result, with separate finite construction limits.

Inputs: file (required), node (required), out, compact, +1 more.

treeA

List node ids, REST types (as in nodes and find) and names under a chosen root. A shallow outline locates pages and frames when their names are unknown; find searches known names or visible text directly.

Inputs: file (required), json, node, depth, +1 more.

usagesA

Exact relations of one node or resource in one stored scope, from the same effective index as search (nested instances and swaps included): direction in (default) lists the locations that point at it, out lists what it points at; with out, an instance_of, uses_style or binds_variable result whose cached library copy names it carries library {kind, namespace, key}, the selector the library argument takes. Relations: instance_of (instance to main component, recorded symbolData or resolved definition/swap), variant_of (component to its set; a COMPONENT_SET node also lists its known members and returns their instances with via), binds_variable (paint, effect and field variable bindings, local or library), uses_style, uses_image (a text range's style comes from the last row of its styleID, as REST nodes give it; its paint images and variables from the first such row with fills, as rendered), prototype_target (recorded transitions; never a claim that a flow is reachable) and contains (asked for explicitly). Every result keeps an exact ref {sourceId, snapshotId, nodeId}, relation, state (resolved, missing, unresolved, unsupported, external, recorded), basis (recorded or resolved), evidence, page, scopeRoot and path; names never establish identity. The definition may lie outside the scope; scope limits only the returned locations. No total is reported; coverage says complete or partial with reasons (work limits, hidden content not expanded, truncated members, library_identity unavailable), and nextCursor pages in a stable order (a workspace library cursor lasts one hour, then cursor_expired). Give file to read that .fig now (nothing is written), or workspaceId to read a source's prepared index of exactly this scope (never builds). Pass snapshotId from the ref you hold: another current snapshot is source_stale. With workspaceId, library {kind, namespace, key} instead of node or resource lists uses_library locations of that library component, style or variable across every visible source's prepared scope (basis cached_copy: the namespace comes from each file's cached copy); the definition stays unresolved (library_source_unproven) unless library.definition selects it by exact ref (selected, keyEvidence unverified), coverage lists each source's state and reasons (source_not_ready, index_partial, namespace_unknown, hidden_excluded, authorization_restricted), and snapshotId, relation and direction do not apply; its results carry ref, name, type, relation, basis, state, evidence, hidden, internal, page and scopeRoot but no path or origin.

Inputs: file, node, limit, scope, +10 more. Returns: scope, state, source, hasMore, +10 more

variablesA
Destructive

The variables a frame binds (collections, modes, aliases); without a node, every local variable. Opt-in format dtcg writes DTCG 2025.10 tokens: requires explicit collection and mode IDs plus out, takes no node, fails without publishing on any diagnostic. An alias into another collection exports its resolved value (aliasOf records the source), read in that collection's only mode or the aliasModes one. No workspace/index needed.

Inputs: file (required), out, mode, node, +3 more. Returns: path, modeId, variables, tokenCount, +4 more

verifyA

Check a bundle, zipped or extracted, against its manifest before building from it: verified, missing and changed files, the bundle's missing assets, and the font faces the visible text uses (with node ids). Each font face is looked up by its name table in this machine's user and system font folders and in fonts (a project font folder): status local_file with localFiles {path, matchedBy, inProject} when a file is found (WOFF/WOFF2 by file name only), else unverified; a match inside fonts also carries a ready fontFace @font-face (src relative to fonts, font-display swap; licensing is the user's call, nothing is copied). local_file never shows the browser loads the face: confirm each in the running project with document.fonts.load, and check browser delivery of assets there. findings gathers these checks with the bundle's unresolved variables, truncated state inventory, render limitations and unemitted semantics into one handoff preflight list, each with node ids, evidence, impact and next action. Reports without blocking; no design file is read.

Inputs: bundle (required), fonts. Returns: path, files, fonts, findings, +5 more

watchA
Destructive

Watching tracked scopes and change-tracking consumers. start: this server holds a lease on tracked scope of one source (sourceId when the workspace has several) and the workspace's shared runner refreshes it on each save, so changes shows new revisions without an index call; the server renews its leases every 10 s and ends them when it exits, and an unrenewed lease ends after 30 s. A requestId replays this server's live lease and reports an ended one as ended (untracked when its scope was untracked or retracked since), never restarting it, for 1 h after the end among the newest 1024 ended leases; past that it is unknown and starts a new lease. A requestId of a lease another running process holds is refused. stop ends one lease this server holds (leaseId). status lists the workspace's leases and runner, read-only. ack moves consumer's checkpoint for these filters (sourceId, scope), or a subscription's own (subscriptionId), forward to cursor, the nextCursor of the last changes page it handled with the same filters; an older or equal cursor normally leaves it, so a retry is safe. A cursor issued before retention deleted revisions it had not passed is event_gap, writing nothing: follow its recovery. A current recovery cursor before a checkpoint that is behind such a deletion moves the checkpoint back to it, so the kept revisions replay. Replies with advanced, true only when the checkpoint moved forward, and the checkpoint now held, which is authoritative. subscribe follows one source, scope or exact node (node: a layer id that must name one layer kind in the published index, else target_missing or identity_uncertain, never a same-name layer) from its newest visible revision; a repeat returns the same subscription; owner marks it temporary for that task. subscribe with query (and type) saves a workspace search of one source's scope (default 0:0) and stores its first evaluation of the top 50; evaluate stores a newer one after a publication, and a watch lease on that scope makes its runner store it unasked; changes with its subscriptionId reads the stored evaluations (causes such as source_changed only for new file bytes or index_rebuilt; enteredTopK and leftTopK are exact sourceId/snapshotId/nodeId refs in the new and old snapshot, rankChanged the new snapshot's refs with from and to positions, null when rankComparable is false, all within the top-50 window, not the whole result set; nodes compare by sourceId, which relocate keeps; total only when the search counted every hit) and reports evaluation pending with an evaluate step, never computing one; an evaluation past 128 KiB is unavailable evaluation_too_large, nothing stored. sources (instead of sourceId) saves the search, or a library question (library), over a fixed set: visible resolves once to the sources this caller sees now, or a comma-separated list, at most 10, returned sorted in subscription.sources; it never gains a source added later. A member's publication evaluates it (its runner too); causes source_changed names members with new bytes in delta.changedSourceIds, corpus_changed a member's relocation or publication, or for a ranked search of several members their shared statistics; refs carry their sourceId and snapshot. A library question lists up to 50 uses with definitionMatch against the definition, followed by its exact nodeId in its source's current snapshot (delta.definitionMatchChanged); coverage.transitive is not_followed: a definition's own library dependencies are never traversed, and delta.notFollowedSourceIds names changed members that hold no use and are not the definition's source, whose dependent uses may be stale. A caller who cannot see every member reads the subscription as unknown; removing a member source disables it (state disabled, disabled.reason source_removed, evaluations deleted; a damaged stored set reads disabled with sources_unreadable): unsubscribe, then subscribe again. list pages the visible subscriptions with their state (subscriptionId: only that one, empty when unknown to the caller). unsubscribe removes one subscription and its checkpoint (or, with owner, that owner's temporary ones); forget removes a consumer's raw checkpoint views. Neither untracks or deletes history. A consumer holds at most 64 subscriptions and checkpoints, a workspace 4096: past that, workspace_busy names list, unsubscribe and forget; nothing is evicted.

Inputs: action (required), workspaceId (required), node, type, +13 more. Returns: next, scope, state, leases, +21 more

workflowA
Read-only

Read built-in figlens skill guidance for this agent: build for design-to-code and project reuse, audit for comparing existing UI with a design and correcting confirmed differences, images for website asset preparation, search for an index, usages and following changes, plan for scoped implementation planning, planning-details for page/multi-page work or unresolved design dependencies, yolo for explicitly requested autonomous implementation and cleanup of what the run created. Returns the requested guide only; no design file, project read/write, implementation, verification or cleanup is performed. Ordinary design questions and exports can use the design tools directly.

Inputs: topic (required).

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.6/5.0

    Scored across 20 tools

    Disambiguation3/5

    Many tools touch the same design graph: tree, find, search, inspect and nodes all help locate or read nodes, while diff, changes and watch all relate to change tracking. The descriptions draw useful boundaries, but an agent must still choose carefully, and watch multiplexes many subscription/change operations into one tool.

    Naming Consistency3/5

    Names are mostly lowercase and readable, but they mix verbs (export, find, inspect) with nouns (tree, nodes, changes) and inconsistent snake_case compounds (export_batch, compare_image). There is no predictable verb_noun convention throughout.

    Tool Count3/5

    Twenty tools is heavy for one server, even though each maps to a real capability across export, inspection, indexing, jobs, models, tracking and verification. The scope is broad enough to justify many tools, but the surface feels unwieldy and several tools bundle multiple operations.

    Completeness4/5

    The set covers inspection, search, single and batch export, bundles, verification, visual comparison, freshness, indexing/jobs and change tracking, so core read-only design workflows have no major dead end. Minor gaps remain, such as explicit image-query search despite image model support, and some lifecycle actions are buried inside compound tools.

    Maintenance

    ActivityMaintained
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      B
      quality
      D
      maintenance
      Enables offline reading and rendering of Figma .fig files, allowing AI agents to extract design specs, export assets, and generate code without needing the Figma API or network access.
      26
      2
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      Enables AI coding agents to read and write a user's Figma file through the Figma Plugin API, offline and privately, without API tokens or rate limits.
      26 npm
      MIT
    • A
      license
      Not graded
      quality
      C
      maintenance
      Enables agents to extract, inspect, search, and bundle design context from local Figma .fig files entirely offline, exposing frame summaries, node context, style tokens, assets, vector SVGs, and visual-match review via MCP.
      MIT
    • A
      license
      A
      quality
      B
      maintenance
      Enables AI agents to read and inspect local Figma .fig files entirely offline, exposing document structure, geometry, styles, text, components, variables, and embedded images via MCP tools.
      12
      100 npm
      3
      MIT