Skip to main content

Tools and prompts

The Figma MCP server provides tools for reading designs out of Figma, writing designs into Figma, connecting designs to your codebase, and building generative plugins and shaders.

Tools are grouped below by workflow. Use the index to jump to a specific tool.

Index​

Read tools​

ToolWhat it doesGroupRemote only
download_assetsDownloads exports and original source imagesDesign to code✓
get_code_connect_mapRetrieves node ID to code component mappingsDesign systems and Code Connect
get_code_connect_suggestionsSuggests mappings (Figma-prompted)Design systems and Code Connect
get_context_for_code_connectComponent metadata for templates (Figma-prompted)Design systems and Code Connect✓
get_design_contextDesign context for a layer or selectionDesign to code
get_figjamConverts FigJam diagrams to XMLDesign to code
get_generative_pluginReads a generative plugin's source manifestGenerative plugins and shaders✓
get_librariesLists subscribed and available librariesDesign systems and Code Connect✓
get_metadataSparse XML outline of a selectionDesign to code
get_motion_contextKeyframe animation data and code snippetsDesign to code
get_screenshotScreenshot of a selectionDesign to code
get_shaderReads a shader effect or fill's source manifestGenerative plugins and shaders
get_variable_defsVariables and styles used in a selectionDesign to code
list_file_shadersLists shaders used in a specific fileGenerative plugins and shaders✓
list_generative_pluginsLists generative plugins in your libraryGenerative plugins and shaders✓
list_shadersLists shader effects and fills in your libraryGenerative plugins and shaders
search_design_systemSearches libraries for components, variables, stylesDesign systems and Code Connect✓
whoamiIdentity and plans of the authenticated userAccount✓

Write tools​

ToolWhat it doesGroupRemote only
add_code_connect_mapMaps a Figma node ID to a code componentDesign systems and Code Connect
create_generative_pluginCreates a generative plugin scaffoldGenerative plugins and shaders✓
create_new_fileCreates a blank Design, FigJam, or Slides fileCode to design✓
create_shaderCreates a shader fill or effect scaffoldGenerative plugins and shaders✓
generate_diagramGenerates a FigJam diagram from MermaidCode to design✓
generate_figma_designGenerates design layers from interfacesCode to design✓
send_code_connect_mappingsConfirms suggested mappings (Figma-prompted)Design systems and Code Connect
update_generative_pluginReplaces a generative plugin's code.ts or ui.htmlGenerative plugins and shaders✓
update_shaderReplaces a shader's main.tsGenerative plugins and shaders✓
upload_assetsUploads images into a Figma fileCode to design✓
use_figmaGeneral-purpose create, edit, and inspectCode to design✓

Weave tools are listed separately. The server also provides one MCP prompt.

note

Not all agents and clients support MCP prompts. Check the documentation for your agent or client to confirm whether MCP prompts are supported.

Design to code​

Tools for reading designs out of Figma and into your codebase. get_design_context is the default entry point: the other tools in this group are either inputs to it, or fallbacks when a selection is too large or you need a specific asset format.

get_design_context​

Supported file types: Figma Design, Figma Make

Use the MCP server to get the design context for a layer or your selection in Figma. By default, the output is React + Tailwind, but you can customize it through your prompt.

If you have shader fills and effects in your design, a lightweight Figma shader runtime is included in the output and requires HTML-in-Canvas to display correctly.

You can ask it to:

  • Change the framework
    • generate my Figma selection in Vue
    • generate my Figma selection in plain HTML + CSS
    • generate my Figma selection in iOS
  • Use your components
    • generate my Figma selection using components from src/components/ui
  • Combine both
    • generate my Figma selection using components from src/ui and style with Tailwind
  • Implement a design that uses shaders
    • implement this Figma frame in React using the included shader runtime
tip

Set up Code Connect for best code reuse results. Code Connect lets you set up multiple connections per Figma library: you can map both your React and SwiftUI code to the same Figma components. The desktop MCP server uses the Code Connect mapping you have selected in Dev Mode. To control which mappings are sent via the remote server, instruct your agent to set the clientFrameworks parameter to the exact Code Connect label you have set up, for example React or SwiftUI.

note

Selection-based prompting only works with the desktop MCP server. The remote server requires a link to a frame or layer to extract context.

get_metadata​

Supported file types: Figma Design

Returns a sparse XML representation of your selection containing just basic properties such as the layer IDs, names, types, position and sizes. This is an outline that your agent can then break down and call get_design_context on to retrieve only the styling information it needs. Useful for very large designs where get_design_context produces output with a large context size.

If you call get_metadata without a nodeId, the tool returns a list of the document's top-level pages (each entry shows the page's id and name) instead of an XML dump. Use this when you don't yet know which page or node to drill into, then call back with one of those page ids to fetch its structure. If you pass an invalid or unknown nodeId, the error response also includes that pages list so the agent has a usable recovery path.

For richer per-page detail such as child counts and top-level node types, use_figma can read the document structure directly via the Plugin API.

get_screenshot​

Supported file types: Figma Design, FigJam, Figma Slides

Allows the agent to take a screenshot of your selection. This helps preserve layout fidelity in the generated code. Recommended to keep on: only turn it off if you're concerned about token limits.

Use download_assets instead if you need multiple nodes, non-PNG formats (SVG, PDF, JPG), full-resolution exports respecting Figma export settings, or the original uploaded source images.

download_assets​

Supported file types: Figma Design, FigJam, Figma Slides

Downloads assets from a Figma file. Returns temporary URLs that must be fetched to retrieve file contents.

Each call returns two types of output for the given nodes: you get both, not one or the other:

  • Export render: The node rendered as an image. If the node has export settings configured in Figma, those are used; otherwise it falls back to the defaultFormat and defaultScale parameters (0.01–4x). Without export settings at scale 1, renders are capped at ~4096px on the longest edge. Supports PNG, JPG, SVG, and PDF.
  • Raw source images: The original uploaded files (JPEG, PNG, GIF, or WebP) placed as fills anywhere in the node's subtree, returned without re-rendering. Capped at 20 per call (rawImagesTruncated: true when there are more: try passing a more specific child node). Useful for cross-file transfer with upload_assets.

Up to 20 nodes can be passed per call.

When to use download_assets vs get_screenshot​

Use get_screenshot when the agent needs to see what a design looks like. Use download_assets when the agent needs to deliver an asset to the user, export in a specific format, or transfer images between files.

get_screenshotdownload_assets
Use whenYou need to visually inspect a designYou need to save, deliver, or transfer an asset
OutputPNG, inline base64 or URLURLs only (PNG, JPG, SVG, PDF, or original source)
NodesSingleUp to 20
Format controlAlways PNGPNG, JPG, SVG, PDF (export); original format (raw)
Original source filesNo: always re-rendersYes: raw mode returns the exact uploaded binary
Inline base64Yes, via enableBase64ResponseNo

You can ask it to:

  • Export assets in a specific format
    • export these icons from my Figma file as SVGs
    • download the hero image from this frame as a JPG
    • export this component as a PDF
  • Extract original source images
    • grab the original photos from this mockup
    • extract the source images from this frame so I can transfer them to another file
  • Cross-file image transfer
    • copy the images from this file into my other Figma file

get_variable_defs​

Supported file types: Figma Design

Returns the variables and styles used in your Figma selection, such as colors, spacing, and typography.

You can ask it to:

  • List all tokens used
    • get the variables used in my Figma selection
  • Focus on a specific type
    • what color and spacing variables are used in my Figma selection?
  • Get both names and values
    • list the variable names and their values used in my Figma selection

get_motion_context​

Supported file types: Figma Design

Returns keyframe animation data for an animated node so agents can faithfully recreate motion in code. The response includes an inventory of animated nodes, keyframe tracks with easing curves, pre-computed CSS @keyframes and motion.dev code snippets, and timeline coordination hints that describe which nodes animate together.

Call get_motion_context after get_design_context when a design contains animation: get_design_context returns the static structure and styling, and get_motion_context supplies the motion layer. Pass the same node id you used for get_design_context. Set recursive: true to return motion data for every animated descendant of the selection in a single call.

get_figjam​

Supported file types: FigJam

Returns metadata for FigJam diagrams in XML format, similar to get_metadata. In addition to basic properties like layer IDs, names, types, positions, and sizes, it also includes screenshots of the nodes.

Code to design​

Tools for writing into Figma: creating and editing files, layers, and content from code or from a description.

tip

These tools work best with a skill. Use figma-use for Figma Design workflows, figma-use-figjam for FigJam, and figma-use-slides for Figma Slides.

use_figma​

Supported file types: Figma Design, FigJam, Figma Slides

The general-purpose tool for writing to Figma files. Use it to create, edit, delete, or inspect objects in Figma Design files, FigJam boards, and Figma Slides decks.

In Figma Design files, use_figma can work with pages, frames, components, variants, variables, styles, text, images, and more. In FigJam, it can work with boards and objects like stickies, sections, connectors, shapes, tables, and code blocks. In Figma Slides, it can work with slides, layouts, text, images, and other deck content.

When relevant, the agent will first check your design system or existing file content before creating anything from scratch.

You can ask it to:

  • Create or modify designs
    • add a new frame to my Figma file
    • update the button component to use the correct fill color
  • Set up design tokens, variables, or styles
    • create a color variable collection from my design tokens
    • set up spacing tokens in my Figma file
  • Build or update component and variant systems
    • generate variants for the card component
    • sync my Figma components with my latest code changes
  • Fix layout or visual issues
    • fix the auto-layout spacing on the nav component
    • update the typography styles to match the design spec
  • Create or update FigJam boards
    • organize this FigJam board into sections
    • add stickies and connectors to summarize this project brief

generate_figma_design​

Supported file types: Figma Design

note

For use with select MCP clients. This tool is exempt from the standard rate limits for the Figma MCP server.

generate_figma_design lets you prompt your MCP client to send live UI for your web apps and sites as design layers to:

  • New Figma Design files
  • Existing Figma Design files
  • Your clipboard

generate_figma_design respects your seat type when creating or editing files. New files are created in your team or organization drafts. For existing files, you must have edit permissions.

For detailed instructions, see Code to canvas.

create_new_file​

Supported file types: No file context required

Creates a new blank Figma Design, FigJam, or Figma Slides file in your drafts folder. If you belong to multiple plans, you'll be asked which team or organization to create the file in.

You can ask it to:

  • Create a new design file
    • create a new Figma file called "Homepage Redesign"
  • Create a new FigJam file
    • create a new FigJam board for our project planning session
  • Create a new Figma Slides file
    • create a new Figma Slides deck for our Q3 review

upload_assets​

Supported file types: Figma Design, FigJam, Figma Slides

Uploads assets (PNG, JPG, GIF, and WebP) into a Figma file. Max 10MB per asset. If a URL to a specific node is provided, the image is uploaded as a fill to that node. Otherwise, new frames are created with the images as fills.

To transfer images between Figma files, use download_assets in raw mode to retrieve the original source images, then upload_assets to place them in the target file.

generate_diagram​

Supported file types: No file context required

Generates a FigJam diagram from Mermaid syntax or natural language descriptions. You do not have to provide Mermaid syntax yourself: describe the diagram you want in natural language and the agent will generate the appropriate Mermaid syntax and call the tool automatically.

Diagrams can be created in a new FigJam file or added to an existing one.

Supported diagram types: Flowchart, Gantt chart, State diagram, Sequence diagram, Architecture diagram, Entity Relationship Diagram (ERD).

You can ask it to:

  • Generate a diagram from a description
    • create a flowchart for the user authentication flow using the Figma MCP generate_diagram tool
    • generate a gantt chart for the project timeline using the Figma MCP generate_diagram tool
    • generate an ERD for a blog database with users, posts, and comments using the Figma MCP generate_diagram tool
  • Convert existing Mermaid syntax
    • create a diagram from this mermaid syntax: ...
tip

To ensure the agent uses this tool, include the directive "Use the Figma MCP generate_diagram tool" in your prompt. In most cases the agent will invoke it automatically when a diagram is needed.

Design systems and Code Connect​

Tools for finding existing design system assets and for mapping Figma components to their implementations in your codebase.

get_libraries​

Supported file types: Figma Design

Get the design libraries associated with a Figma file. Returns two lists: libraries currently added to the file (subscribed), and libraries available to add (community UI kits and organization libraries). Each library includes its name, library key, description, and source type. Used alongside search_design_system.

search_design_system​

Supported file types: Figma Design

Searches across all connected design libraries to find components, variables, and styles matching a text query. Returns matching assets so the agent can reuse existing design system elements rather than creating new ones from scratch.

When your agent uses the tool, it passes items as queries, which each express one search intent. The agent will pass a number of queries per call and gets results based on the text of each query.

You can ask it to:

  • Find components
    • search for a button component in my design system
    • find a card component I can use for this layout
  • Look up tokens
    • search for the primary color variable in my design system
    • find spacing tokens in my design libraries
  • Narrow by type
    • search for icon styles in my design system

get_code_connect_map​

Supported file types: Figma Design

Retrieves a mapping between selected Figma instance node IDs and their corresponding Code Connect components in your codebase.

Returns an object where each key is a Figma node ID (an instance in the current selection), and the value contains metadata about the connected component:

  • componentName: the name of the component in your codebase
  • source: the location of the component in your codebase (file path or URL)
  • snippet, snippetImports, snippetNestedFunctions: snippet data when available
  • version: the source of the mapping (for example, Code Connect UI vs Code Connect CLI)
  • label: the framework label (for example, React) when available

If multiple instances of the same component are selected, each appears as a separate entry. The mapping may also include nested components that have their own Code Connect mappings, such as an icon inside a component.

On the remote server, use clientFrameworks and clientLanguages to control which mappings are returned.

add_code_connect_map​

Supported file types: Figma Design

Adds a mapping between a Figma node ID and its corresponding code component in your codebase. Setting up these mappings improves the output quality of design-to-code workflows and helps you identify and use the exact component in your project.

Figma-prompted tools​

The following tools are invoked by Figma or by the figma-code-connect skill as part of a larger flow. They are not intended for direct invocation by a user.

get_code_connect_suggestions​

Supported file types: Figma Design

Detects and suggests mappings of Figma components to code components in your codebase using Code Connect.

get_context_for_code_connect​

Supported file types: Figma Design

Retrieves context for generating Code Connect templates. Returns structured component metadata including property definitions with types and variant options, and a tree of descendant instances and text nodes with their property references.

send_code_connect_mappings​

Supported file types: Figma Design

Confirms the Code Connect mappings after calling get_code_connect_suggestions.

Generative plugins and shaders​

Tools for reading and writing the source code behind generative plugins, shader fills, and shader effects: the resources you build by prompting the Figma agent.

Two resource families, each with list, read, create, and update tools:

ResourceListReadCreateUpdate
Generative pluginlist_generative_pluginsget_generative_plugincreate_generative_pluginupdate_generative_plugin
Shader (effect or fill)list_shaders, list_file_shadersget_shadercreate_shader (kind)update_shader (kind)
caution

Writing requires a skill. create_shader and update_shader require the figma-shaders skill. create_generative_plugin and update_generative_plugin require the figma-generative-plugins skill. These are mandatory prerequisites: load them before calling.

The following apply across this group:

  • Access. You can access the code for any shader, but only for your own plugins. Every list and get response includes an owner field: your email, figma, or a publisher handle.
  • Create returns a scaffold. create_* produces a runnable starter, not a finished resource. Always follow it with the matching update_*.
  • Updates replace existing files only. Send complete content per file, never a diff. Unspecified files are preserved, and new files cannot be created. Shaders expose main.ts; plugins expose code.ts and ui.html.
  • planKey comes from whoami. Take it verbatim from the returned plans list.
note

list_shaders and get_shader replace the per-kind tools list_shader_effects, list_shader_fills, get_shader_effect, and get_shader_fill, which are deprecated.

list_generative_plugins​

Supported file types: No file context required

Lists the generative plugins in the authenticated user's account library, including Figma's first-party plugins. Generative plugins are runnable tools that modify the canvas, distinct from shader effects and shader fills.

Parameters: cursor (optional): a pagination cursor returned as nextCursor by a previous call. Omit to fetch the first page.

Returns: For each plugin, its id, name, description, and owner, plus a nextCursor when more pages exist. owner is your email address for plugins you own, or a public publisher handle otherwise.

You can ask it to:

  • See what's available
    • list my generative plugins
  • Find one to edit
    • find my layer-renaming plugin so I can update it

get_generative_plugin​

Supported file types: No file context required

Reads a generative plugin from the account library by id.

Parameters:

  • id: the plugin id, from list_generative_plugins
  • version (optional): a 40-character commit SHA. Defaults to the latest built version.
  • includeSource (optional, default false): inline each file's source in the result instead of returning URIs. Only for clients that cannot read MCP resources. Capped at 100 files and 1,000,000 cumulative bytes; the result reports which limit truncated it.

Returns: The plugin's name, description, owner, version, and a manifest of its source files as { filename, bytes, uri }. File contents are not inlined by default: read each file from its uri as an MCP resource.

You can ask it to:

  • Inspect a plugin's source: show me the source for my layer-renaming plugin
  • Read a specific version: get version <commit SHA> of my layer-renaming plugin

create_generative_plugin​

Supported file types: No file context required

Creates a new generative plugin in the authenticated user's account library and returns its id.

The plugin starts as a working scaffold: a runnable starter that draws a square. Follow this call with update_generative_plugin to replace the scaffold's source with the behavior you want.

Parameters:

  • name: the plugin's display name
  • description: a short description of what the plugin does
  • planKey: the plan that will own the plugin, matching (team|organization)::<numeric-id>. Take the key verbatim from the plans list returned by whoami.

Returns: The id of the new plugin, or an error message.

You can ask it to:

  • Start a new plugin
    • create a new generative plugin called "Layer renamer" in my team plan
  • Scaffold before writing behavior
    • scaffold a generative plugin, then update it to batch-rename my selected layers

update_generative_plugin​

Supported file types: No file context required

Updates an existing generative plugin. The update is built, versioned, and deployed.

Requires the figma-generative-plugins skill.

Parameters:

  • id: the plugin id
  • commitMessage: required. A Git commit message describing the change.
  • files (optional, default []): an array of { path, content }. path must be code.ts or ui.html; content must be the complete replacement file, not a diff. Unspecified files are preserved. Read the current source with get_generative_plugin before overwriting.
  • metadata (optional): { name, description } to change the plugin's display name or description. An empty files array with metadata performs a metadata-only update.

Returns: The new version when present, or an error. Treat any non-error response as success: a successful response may omit the version. A build failure returns compiler output; make the smallest correction it identifies and retry once.

note

code.ts is the sandbox entrypoint and the only side that can call figma.*. ui.html is the panel and the only side with DOM access; it uses PropsKit fig-* elements. manifest.json cannot be replaced, and new files cannot be created.

list_shaders​

Supported file types: No file context required

Lists the shader effects and shader fills in the authenticated user's account library, in one call.

Parameters: cursor (optional): pagination cursor.

Returns: For each shader, its id, name, description, owner, and type: "effect" (samples an input raster) or "fill" (generates pixels directly), plus a nextCursor when more pages exist. owner is your email address for shaders you own, or figma for first-party shaders. Use the id with get_shader.

You can ask it to:

  • See what's available: list the shaders in my library
  • Find one to edit: find my star field shader

get_shader​

Supported file types: No file context required

Reads a shader effect or shader fill from the account library by id.

Parameters:

  • id: the shader id, from list_shaders
  • version (optional): a 40-character commit SHA. Defaults to the latest built version.
  • includeSource (optional, default false): inline each file's source in the result instead of returning URIs. Only for clients that cannot read MCP resources. Capped at 100 files and 1,000,000 cumulative bytes; the result reports which limit truncated it.

Returns: The shader's name, description, owner, type, version, and a manifest of its source files as { filename, bytes, uri }. File contents are not inlined by default: read each file from its uri as an MCP resource.

You can ask it to:

  • Inspect a shader's source: show me the source for my star field shader
  • Read a specific version: get version <commit SHA> of my star field shader

create_shader​

Supported file types: No file context required

Creates a new shader effect or shader fill in the authenticated user's account library and returns its id. Like create_generative_plugin, this returns a working scaffold: follow it with update_shader.

Requires the figma-shaders skill.

Parameters:

  • name: the shader's display name
  • description: a one-line description of what it does
  • planKey: the owning plan, matching (team|organization)::<numeric-id>, taken verbatim from whoami
  • kind: "effect" for a shader that transforms the layer beneath it, or "fill" for a shader that generates its own pixels

Returns: The id of the new shader, or an error message.

You can ask it to:

  • Start a shader fill: create a shader fill called "Topographic contours" in my team plan
  • Start a shader effect: create a shader effect called "Chromatic blur" in my organization plan

update_shader​

Supported file types: No file context required

Updates an existing shader effect or shader fill. The update is built, versioned, and deployed.

Requires the figma-shaders skill.

Parameters:

  • id: the shader id
  • kind: "effect" or "fill", and it must match the existing resource. Do not switch kinds during an update.
  • commitMessage: required.
  • files (optional, default []): an array of { path, content }. path must be main.ts; content must be the complete replacement file, not a diff. An empty array is valid for a metadata-only update.
  • metadata (optional): { name, description } to change the shader's display name or description.

Returns: The new version when present, or an error. Treat any non-error response as success: a successful response may omit the version. A build failure returns compiler output; make the smallest correction it identifies and retry once.

list_file_shaders​

Supported file types: Figma Design

Lists the shader effects and shader fills used in a specific Figma file. This is the tool to reach for when you want to read a shader you do not own: it requires view access to the file, not ownership of the shader.

Parameters: fileKey: the key of the Figma file.

Returns: For each shader:

FieldMeaning
idThe shader id
nameDisplay name
descriptionShort description
type"effect" (samples an input raster) or "fill" (generates pixels directly)
versionThe exact version referenced by the file
publishedWhether this is a published library version
truncatedPer-shader: true when the manifest hit its 10,000-file safety cap
filesManifest of authored source files as { filename, uri }

A top-level truncated: true means a referenced shader could not be returned, including when the file references more than the 100 shaders returned.

Source reads are pinned to the exact shader version referenced by the file, so what you read is what the file renders.

You can ask it to:

  • Inspect shaders in a file you're working from
    • what shaders are used in this Figma file?
  • Read a shader you don't own
    • show me the source for the background shader in this file

Account​

whoami​

Supported file types: No file context required

Returns the identity of the user that's authenticated to Figma:

  • The user's email address
  • All of the plans the user belongs to
  • The seat type the user has on each plan
tip

whoami is a prerequisite for create_generative_plugin and create_shader: both require a planKey taken verbatim from the plans list this tool returns.

Weave tools​

note

Running a Figma Weave tool through MCP uses your Weave credits, not your Figma AI credits. Your agent will show you the cost and ask for confirmation before running: free runs skip this step. A paid standalone Figma Weave account is required to run Weave tools.

weave_list_tools​

Supported file types: No file context required

Lists the Weave tools the authenticated user can run in their active Weave workspace. These are published Weave workflows, including their own tools, tools shared with the whole workspace, and tools shared with them directly by email. Private tools are not returned.

Here "tool" means a published Weave workflow, not an agent or MCP tool.

Parameters: search (optional): a case-insensitive substring matched against tool names, for looking up a tool the user named.

Returns: The most recently updated tools and the total number available. For each tool: its name, who created it, when it was last updated, and a link to open it in Weave.

You can ask it to:

  • Browse available tools: show me the Weave tools I can run
  • Find a specific tool: find the "image generator" Weave tool
tip

If you already have a Weave URL (app.weavy.ai/tool/<id> or app.weavy.ai/flow/<id>), the <id> is the recipeId. Skip this tool and go straight to weave_get_tool_inputs.

weave_get_tool_inputs​

Supported file types: No file context required

Gets the input contract of a Weave tool: the inputs you fill in to run it. Call before weave_run_tool to learn what to send.

Parameters:

  • recipeId: the id of the Weave tool, from weave_list_tools
  • version (optional): tool version to inspect; omit for latest

Returns: The resolved version, an outputs summary, and a flat inputs list (nodeId, name, type, required, description, options, range, isIterator, default).

You can ask it to:

  • See what a tool needs: what inputs does the "image generator" Weave tool take?
  • Review current values before a run: show me the inputs and their defaults for this Weave tool

weave_upload_asset​

Supported file types: Image (PNG, JPG/JPEG, WebP, HEIC), video (MP4, MOV, WebM), audio (MP3, WAV, OGG, and other common formats), and 3D model (GLB, OBJ, FBX, PLY)

Turns an attached file into a hosted URL to pass into weave_run_tool. Files already at a public HTTPS URL don't need this step.

Parameters: recipeId: the Weave tool the asset is for.

Returns: A single-use submitUrl to upload bytes to; after upload, the permanent hosted URL(s).

You can ask it to:

  • Use an attached image in a run: use this image as the reference input for the Weave tool
  • Turn a local or attached file into a URL: upload this file to Weave so I can run a tool on it

weave_run_tool​

Supported file types: No file context required

Runs a Weave tool and returns run IDs to poll with weave_get_tool_run_output. Call weave_get_tool_inputs first.

Because running spends credits, this tool is gated: it returns inputs_required if inputs are missing or invalid, or cost_confirmation_required with the credit cost: confirm with the user, then re-call with acknowledgedCost set.

Parameters: recipeId, version (optional), inputs (optional: an array of {nodeId, value}), numberOfRuns (optional, 1–10), acknowledgedCost (optional).

Returns: runIds of started runs, or a gate status.

You can ask it to:

  • Run a tool with a prompt: run the "image generator" Weave tool with the prompt "a cat"
  • Run a tool several times: run this Weave tool 3 times

weave_get_tool_run_output​

Supported file types: No file context required

Gets the output and status of runs. Poll after running a tool.

Parameters: recipeId, runIds (optional).

Returns: Per-run status (RUNNING / COMPLETED / FAILED / CANCELED), progress, error, and outputs when complete.

You can ask it to:

  • Check on a run: is my Weave run done yet?
  • Get the latest output: show me the output of my last Weave run

weave_cancel_tool_run​

Supported file types: No file context required

Cancels one or more in-progress runs. Cannot be undone.

Parameters: recipeId, runIds (optional: omit to cancel all).

Returns: Confirmation of canceled runs.

You can ask it to:

  • Stop a specific run: cancel that Weave run
  • Stop everything running: cancel all my running Weave tool runs

Prompts​

note

MCP server prompts are distinct from the prompts you use to chat with an agent. They are provided by an MCP server and invoked using commands specific to the agent or client you're working with. Not all agents and clients support MCP prompts.

create_design_system_rules​

Supported file types: No file context required

A prompt for creating a rule file that provides agents with the right context to translate designs into high-quality, codebase-aware frontend code. It helps ensure alignment with your design system and tech stack, improving the relevance and accuracy of generated output.

Run this prompt and make sure the result is saved to the correct rules/ or instructions/ path so your agent can access it during code generation.