Generate and refine UI designs with Subframe through AI assistants. Create polished React components and responsive layouts from natural-language prompts, explore design variations, and turn design concepts into production-ready code.
Kiro is AWS's agentic IDE, with a terminal CLI alongside it. Both read remote MCP servers from the same user config and sign in to them with OAuth.
This guide connects Subframe MCP to Kiro through MewCP, so Kiro can use Subframe MCP's 70 tools, like open_editor_session, open_subframe and list_projects, without your Subframe MCP credentials ever reaching the app.
Subframe MCP signs in through managed OAuth. MewCP stores the token encrypted, refreshes it before it expires and injects it only at call time. Your agent never holds it, so it can never leak it.
More apps
Manage repositories, pull requests, issues, branches and development workflows on GitHub. Automate software delivery and collaborate across engineering projects.
Connect to external APIs, webhooks and internet services through standard HTTP requests. Build integrations with virtually any platform that exposes a web-based interface.
Turn your AI agent into a creative studio The world's best image, video, audio and 3D models, inside the AI assistant you already use.
Give AI coding agents access to a curated library of real-world website designs, screenshots, design systems, and reusable UI components. Search visual references, find similar designs, analyze layouts, extract colors and typography, compare websites, and retrieve copy-ready JSX components for building better interfaces
Other clients
Subframe MCP works the same way in every client below. Pick yours for its own guide.
Free to start.
Scope access to the exact Subframe MCP tools and accounts you allow, work and personal side by side. Anything outside that scope is refused at call time, even when the model asks for it.
Each call is logged: what ran, on which account, and whether it worked. Failures come back structured, so the agent knows whether to retry instead of guessing.
Every app sits behind one secure MCP URL, and there is no server for you to deploy or keep running. Add an integration in the dashboard and it is live on the next call, with no config to change and no new credentials to wire up. Tools load only when a task needs them, so your agent stays fast and focused however many apps you connect.
Open the Command Palette, run Kiro: Open user MCP config (JSON) (~/.kiro/settings/mcp.json), and merge this into "mcpServers". Saving reloads it.
A browser window opens when Kiro connects. Sign in and approve access. No API key needed.
Start a new chat and ask: "List the tools you can use from MewCP." You should see your connected apps. If no tools show, open Settings, search "MCP", and turn on MCP support.
Used by the Subframe widget, not for direct use. Returns a short-lived credential for the embedded Subframe editor, which opens on this project.
Design work isn’t done until the user has seen it. Your text can’t show how a design looks, and the user often wants to adjust something by hand rather than describe it to you. `open_subframe` lets them load the Subframe editor in the chat where supported; elsewhere it returns links in its text and each item’s `url`. Call it once as the last tool call of any turn that changed something in the project, after any pending jobs. `items` lists everything changed as `{kind, id?}` (page, component, snippet, canvas, document, theme), using returned IDs; omit the ID for theme, including fonts and icons. `open` chooses which item Open lands on (defaults to the first found item): use the shared canvas when changed pages share one (include it in `items`), otherwise the most useful item. Skip it if nothing changed that can be opened (read-only, image-only, empty new projects). Also use it when asked to open a design or project. Without `items`, it opens the given `projectId` on its first canvas (or theme if none); without `projectId`, it opens the user’s only project or lists their projects, most recently edited first, for them to choose. With no projects, it errors and points to `create_project`.
Lists all projects the user has access to. Call this tool to find a projectId if the user has not specified one and does not have a sync.json file. If the user has only one project, use that projectId automatically for subsequent tool calls. If the user has multiple projects, present the list of project names so the user can choose which project to work with. An empty list means the user has no Subframe projects yet: create one with create_project, or if that tool isn't available, tell them to create one in the Subframe app (https://app.subframe.com), then call this tool again. Never show teamId to the user; pass it to generate_auth_token or create_project, and show teamName only when the user has several teams.
Creates a project in one of the user's teams and returns its projectId for subsequent tool calls. Use it when list_projects returns no projects or the user asks for a new project. A team on the Free plan can have 1 project.
Gets project information including design documentation. Each project document has an id, title, isPinned and contents; the pinned document is the project's design guidelines.
Returns one theme as typed JSON (the default theme unless themeId selects another), plus responsive breakpoints and available font families. Token values use exactly the shapes edit_theme accepts (colors as "#rrggbb" or "#rrggbbaa", or rgb() when hex would round the stored color, typography { fontFamily, fontSize px, lineHeight px, fontWeight, letterSpacing em }, corners { radius px }, shadows as layer arrays, borders { width, style, color }, aliases as { alias: tokenName }), so a value read here can be written back unchanged. Each token carries its id, name and valueDark (null inherits the base value). Colors also carry slug (e.g. brand-600, which color utilities use as bg-brand-600) and folder; typography, corner, shadow and border tokens instead carry className, the exact classes that apply them (e.g. rounded-lg, text-body font-body). The result also includes the theme's defaults (font family and text color) and border tokens. A project can hold several themes that share token names and ids but differ in values; list_themes returns their ids. Breakpoints are project-wide width ranges where styles can differ. Each carries its id, name, styling prefix, isDefault and the viewport range it covers in px: minWidth (null for the narrowest) and maxWidth (null for the default). A non-default breakpoint applies at its maxWidth and narrower and has a prefix; the default breakpoint (usually Desktop) is the base, has no prefix or width of its own, and covers everything wider than the other breakpoints, so to change where it starts, change the widest other breakpoint. Breakpoint IDs are what screenshot tools accept; inspect them before authoring responsive JSX or targeting a non-default screenshot. Use an exact name from availableFonts when adding or changing a theme font. Pass cssType only when you need the Tailwind code export (for implementing designs): the result then also includes a css field.
Lists the project's themes with their ids and which one is the default theme (it cannot be deleted). A project can hold several themes that share token names and ids but differ in values. Use the ids as themeId for get_theme, edit_theme, import_theme and delete_theme, and as id for rename and duplicate.
Search the project's icons (built-in Lucide icons and uploads) by describing what you want (e.g. 'warning triangle', 'shopping cart'). Projects differ in which icons they have. Returns the most relevant matches first; use a result's exact name in edit_page / edit_snippet code, e.g. <SubframeCore.Icon name="FeatherCheck" /> or <Button icon="FeatherCheck" />.
Edit a project's theme with a batch of typed operations: create, update, rename or delete tokens (color, typography, corner, shadow, border; breakpoints can be created, updated and renamed but not deleted; the default breakpoint can be renamed but has no width to update, because it covers everything wider than the other breakpoints, so to change where it starts, change the widest other breakpoint), set the theme defaults, and turn dark mode on or off. Values have exactly the shapes get_theme returns, so you can read a value and write it back; the tool description of each field lists the shapes and units. The batch is atomic: every operation is validated first, and if any fails nothing is applied (the failed operation reports its reason and later ones report skipped). Every operation gets its own result in order: applied (the stored name and scope, plus the stored value when a create or update wrote one (for an update that sent only valueDark it is the dark override, absent when none remains or the update only moved a folder), and a note when there is something to flag), unchanged (no other fields; already in the requested state, so re-sending creates, updates, defaults and dark mode is safe; a rename or delete whose target is already gone fails, so drop it), failed or skipped (each with a reason). Pass dryRun: true to validate and see the results without saving; an operation that would change the theme then reports would-apply instead of applied, and applied is false. Nothing is silently changed: an unknown font, an unparseable value, a name that is taken, a name that does not exist, an alias that would loop and a dark value on a theme without dark mode all fail with a reason that says how to fix them. A token is addressed by type and name; names are shared by every theme and match ignoring case and spaces versus dashes. create, rename, delete and folder membership apply to every theme (create seeds the same value into each); update of a token, set_defaults and set_dark_mode change only the theme named by themeId, which is required once the project has more than one theme (list_themes returns them). Breakpoints are project-wide: creating, updating and renaming one applies to every theme and needs no themeId. Changing the default theme's default font family also moves text hardcoded to the old family to the new one, since designs are shared by every theme; another theme's set_defaults changes only that theme. Themes themselves are added with duplicate, renamed with rename and removed with delete_theme. Each applied result says its scope (all-themes or theme). value is the theme's base mode and valueDark its dark override (null clears the override). An alias is { alias: tokenName } to another token of the same type, set per theme and mode. A delete refuses while the token is used by nodes, other tokens, border colors or the default text color: pass replaceWith (another token of the same type that takes over every use) or detach: true (nodes are hardcoded to the default theme's base value, losing per-theme and dark variation; tokens and default text colors that use it take its value in each theme). Deleting is destructive, so confirm with the user before deleting or detaching, even when they asked for it. Deleting a folder deletes its colors under the same rule, and deleting a folder's last color removes the folder. Use an exact font name from get_theme availableFonts; to add a font first call create_asset_upload and add_fonts. To adopt pasted Tailwind CSS or a tailwind config, call import_theme instead of writing operations by hand. Theme version history can revert theme changes, but references hardcoded by detach come back only through project-level version history.
Imports a theme into a project from source you paste: Tailwind v4 CSS (@theme blocks, :root variables, a .dark block for dark mode, @custom-variant max-width breakpoints) or a Tailwind v3 config (tailwind.config.js). Pass the source verbatim instead of retyping it as edit_theme operations. Parsing is deterministic; when the source uses var() inside a color function, calc(), or a tailwindcss/colors import, an AI pass first rewrites that notation into plain values and makes no design decisions. The import is additive: it creates tokens, updates tokens that already exist by name, turns dark mode on when the source has dark values, and never deletes. An orphan --font-sans (or fontFamily.sans) sets the theme's default font family. Like edit_theme the import is atomic: it compiles to edit_theme operations and applies them as one batch, so a failure applies nothing. The result is edit_theme's result for those operations plus operations (what the source compiled to; run with dryRun: true first to amend any you disagree with and send them through edit_theme instead) and skipped (every declaration it could not import, each with a reason, such as an unsupported namespace like --spacing-*, a value that could not be parsed, or a font that is not in the project: add it with create_asset_upload and add_fonts, then import again). Pass dryRun: true to see operations and skipped without saving; the results then report would-apply instead of applied, and applied is false. themeId selects the theme whose values are updated; it is required when the project has more than one theme, and new tokens are added to every theme.
Gets information about a canvas, including the page IDs that belong to it. A canvas is a collection of related pages organized together (e.g. 'Onboarding', 'Settings', 'Checkout'). Pages sit at pixel positions on an infinite canvas, may overlap, and are listed in reading order. Each page's position is its tile's top-left in canvas pixels; the placement tools measure page heights when they place, so pass a page id as anchorPageId to a placement tool (create_page, move, duplicate) to sit beside it. One of id, name, or url must be provided. Example URL: https://app.subframe.com/3d102b8b7968/canvas/dfe2fb91-f350-4db0-8c71-9d3dd0ee6a9c/edit
Lists all components and page layouts in the project and the folder each is filed in. Use list_folders to see the folders themselves.
Lists every folder in the project, including empty ones, with the components and page layouts filed in each. Folders group components — e.g. by release phase; file components into them with move. Folder names aren't unique, so refer to a folder by its id.
Lists all pages in the project.
Lists all canvases in the project. A canvas is a collection of related pages organized together (e.g. 'Onboarding', 'Settings', 'Checkout'). Use this to discover groupings before drilling into a specific canvas with get_canvas_info, or as a more focused alternative to list_pages on projects with many pages.
Lists all snippets in the project. Snippets are reusable designs typically embedded in design documents as examples.
Generates the code and other info for a component. By default, files contain standard export-faithful component code. Set includeEditorMetadata only for component authoring or questions about Subframe editor defaults and round-trip behavior. One of id, name, or url must be provided. Example component id: dfe2fb91-f350-4db0-8c71-9d3dd0ee6a9c. Example component names: Button, TextField. Example URLs: https://app.subframe.com/3d102b8b7968/library?component=Button_3b777358-b86b-40af-9327-891efc6826fe https://app.subframe.com/3d102b8b7968/design/3b777358-b86b-40af-9327-891efc6826fe/edit. Each files[].directory is relative to the sync.json "directory" root, where "" means the root itself. Keep component-example tags in designDocuments content verbatim when writing it back.
Generates the code for a page. One of id, name, or url must be provided. Example page id: dfe2fb91-f350-4db0-8c71-9d3dd0ee6a9c. Example page names: ReportingDashboard, ModernHomePage. Example URL: https://app.subframe.com/3d102b8b7967/design/dfe2fb91-f350-4db0-8c71-9d3dd0ee6a9c/edit
Generates the code and other info for a snippet. Snippets are reusable designs typically embedded in design documents as examples. One of id, name, or url must be provided.
Have Subframe's AI generate 1-4 page variations as a background job. To write a page yourself, use create_page then edit_page; use this when the user asks for Subframe's AI to generate pages or options in the background. For an exact copy of a page, use duplicate. The generator only sees project pages you pass to it, so when the project has pages that should be used to inform the new design(s), pass the 1-4 most relevant pages as `subframe` references. Returns a canvas URL where each successful variation appears as a page, the canvasId, a jobId, and plannedPages (the id and name each variation's page will have if it succeeds). Pass the jobId to wait_for_jobs, whose done result lists the canvasId, the applied-page count and the pageIds of the pages that now exist (a failed variation has no entry), before reading the canvas or deciding whether any missing variations should be retried. Each variation's spot on the canvas is reserved when you call; a page that has since taken it pushes the variation right.
Apply a targeted edit to one node of an existing Subframe page. Pass the nodeId you want to change, calling get_page_info with includeNodeIds: true only if you don't already hold it from an earlier result. Replace the node and its subtree, insert your code as a new sibling above/below it, append it as the node's last child, or delete it. More than about 15 lines in one call means split it: a card is its container, then each row. To change only an element's styling, use update_node_styles instead of replace — update_node_styles preserves all children. The edit is applied immediately and returns any parser warnings. The returned appliedCode carries each element's data-node-id, so target those nodes in follow-up edits directly instead of re-reading the page. A replaced or inserted subtree always gets fresh node ids (repeating a data-node-id carries that node's comments and prototype links over, not its id): the result returns the new subtree's root as nodeId, and a replaced node's old id stops existing. The user can undo via page version history in the Subframe editor.
Place a new empty page on a canvas, for you to fill with edit_page. No Subframe AI runs. Call it once you've read what you need and are ready to write, right before your first edit_page; the named canvas is created when none matches. The result returns the pageId, canvasId and the page's rect on the canvas, a link to the page, and rootNodeId. Then immediately add content with edit_page's insert-children operation, starting on rootNodeId, one visual group per call (a header, a hero, a card's container then each row), because the user watches the canvas in real time; more than about 15 lines in one call means split it. Check the result with screenshot_page and fix problems with edit_page or update_node_styles.
Get Subframe's reference by topic: pages (the JSX and Tailwind subset Subframe parses into an editable page, page structure, responsive styling, popup structures, and design rules), components (the component code Subframe parses into props, variants and slots, which templates to copy, and preview sizing) and import (bringing an existing codebase's or website's design system into Subframe: inventory, fonts, icons, theme tokens and components). Read pages or components before you first write that kind of design in a session, and import before an import.
Get Subframe's guidance for implementing designs in a codebase: component ownership (Subframe sync or the app's own components), getting the code, and verifying the implementation against the design. Read it before implementing or updating a Subframe design in a codebase.
Have Subframe's AI design a new component, or edit an existing one when component is given, as a background job. Use it only when the user asks for Subframe's AI; otherwise write the component yourself with create_component and edit_component. Returns immediately with the componentId, a URL to the component editor where the user can watch the agent work, and a jobId. If you need to read the result (e.g. via get_component_info) before continuing, pass the jobId to wait_for_jobs first.
Create a new component for you to build with edit_component. No Subframe AI runs. Omit `from` for an empty component, or pass a template or project component as `from` to copy it. Copy the matching template whenever the component IS one of the behavioral types listed in get_design_guidance's components topic (read it before your first component in a session), since their behavior can't be built from scratch. Returns the component's editing code and version. Then build it with edit_component, one visual group per call (the container, then each part), because the user watches the component editor in real time.
Change an existing component's code yourself. No Subframe AI runs. Edit the code from get_component_info with includeEditorMetadata: true (or from an earlier create_component or edit_component result, which return the current code): send edits, exact old_str/new_str replacements applied in order, or code, the whole file with the baseVersion of the read you started from. Prefer edits once a component is non-trivial, and grow a new one one visual group per call. Keep the prop id comments and data-node-id attributes on everything you keep, since they carry each prop's and element's identity, and instances in pages keep their values through them. A target that is part of a compound component edits its whole family. The result returns the current code and version, so follow-up edits don't need a re-read. Edits apply to every page that uses the component; the user can undo via version history.
Design a snippet in Subframe. Snippets are small bits of reusable UI typically embedded in design documents as examples (e.g., a Button example showing all variants). Creates the snippet based off the description and then returns a URL to the snippet editor.
Create a new empty snippet, for you to fill with edit_snippet. No Subframe AI runs. Snippets are small bits of reusable UI typically embedded in design documents as examples (e.g., a Button example showing all variants). The result returns the snippetId, a link to the snippet editor, and rootNodeId. Then add the content with edit_snippet's insert-children operation on rootNodeId, and check it with get_snippet_info.
Apply a targeted edit to one node of an existing Subframe snippet. First call get_snippet_info with includeNodeIds: true to see each element's data-node-id, then pass the nodeId you want to change. Replace the node and its subtree, insert your code as a new sibling above/below it or as its last child, or delete it. To change only an element's styling, use update_node_styles instead of replace — update_node_styles preserves all children. The edit is applied immediately and returns any parser warnings. The returned appliedCode carries each element's data-node-id, so target those nodes in follow-up edits directly instead of re-reading the snippet. A replaced or inserted subtree always gets fresh node ids (repeating a data-node-id carries that node's comments and prototype links over, not its id): the result returns the new subtree's root as nodeId, and a replaced node's old id stops existing. The user can undo via snippet version history in the Subframe editor.
Apply the same complete Tailwind className to one or more elements on a single existing Subframe page or snippet without touching their structure or content. Prefer this over edit_page / edit_snippet with 'replace' whenever changing only styling. First call get_page_info or get_snippet_info with includeNodeIds: true to find the elements' data-node-id values, then pass them in nodeIds (a one-item array for one element). The provided className fully replaces every target's current classes, so batch only elements that should share the entire class list, including sizing and layout. Descendants are untouched unless explicitly targeted. Returns each target's canonical className and warnings in request order, and the page or snippet as pageId or snippetId (definitionId repeats it).
Wait for background AI jobs to finish. Pass the jobIds returned by any relevant tools. Each status is 'running' (still working), 'done' (finished with at least one usable result; the summary may report partial batch success), 'error' (the job failed, produced no requested result, or stopped reporting — read the summary; a job that stopped reporting may still have applied, so check its target before relaunching), or 'not_found' (unknown id, or scoped to a different team). If you need to know when a set of jobs has finished, call this tool in a loop until every job is 'done' or 'error'.
Delete a page from the project. The page is removed from any canvas it belongs to and prototype actions referencing it are stripped. By default, refuses if the page is referenced by other definitions — pass "force: true" to delete anyway. Deletion is irreversible from MCP — use project version history in the Subframe editor to restore the page.
Delete a component or custom page layout from the project. Deleting a component removes access to its component-level version history. Restoring it requires project-level version history, which may revert unrelated changes. Never use this tool to work around a component that is empty, broken, or corrupted, or when an edit fails; the user may want to restore the component to a previous working state using component-level version history. For detachable components, instances in other designs are detached. For non-detachable components that are still deletable, instances in other designs are deleted, including customized content inside them. Layout is cleared on every page using it. Some built-in components cannot be deleted, and "force: true" does not override that. By default, refuses if the component/layout is in use — pass "force: true" only after the user explicitly confirms deletion despite those references. Deletion is irreversible from MCP.
Delete a snippet from the project. Any embeds in design docs (`<div data-component-id>` blocks) are scrubbed automatically. Deletion is irreversible from MCP — use project version history in the Subframe editor to restore the snippet.
Delete a theme from the project. The default theme cannot be deleted: every project keeps it, so it is also the last theme left. Pages and components do not belong to a theme, so none are affected, and tokens stay in the remaining themes. Deletion is irreversible from MCP — use theme version history in the Subframe editor to restore the theme. Confirm with the user before deleting unless they asked for it.
Delete a canvas from the project. By default, refuses if the canvas contains any pages — pass "deleteChildPages: true" to delete the canvas and every page inside it. Deleting child pages will also remove references to them from other pages. Deletion is irreversible from MCP — use project version history in the Subframe editor to restore the canvas and its pages.
Delete a folder from the project. By default, refuses if the folder contains any components or page layouts — pass "deleteContents: true" to delete the folder and everything in it, as the editor does. To keep the components, first take them out with move (folder: null). Refuses, naming them, if the folder contains components that can't be deleted. Deletion is irreversible from MCP — use project version history in the Subframe editor to restore the deleted components.
Deletes the project for the whole team. It can't be restored from MCP or the app. Only call this when the user asks to delete the project.
Rename a page, component, snippet, page layout, canvas, component folder, or theme. Theme ids come from list_themes. If the requested name is already taken, it is de-duplicated (e.g. "Name 2") and the final name is returned — except for folders, whose names don't have to be unique and are applied as given. If id, name, or url matches more than one item, the call errors and lists each match — pass an id to disambiguate.
Move pages between canvases and spots on a canvas, and file components and page layouts into folders, in one call. A page move gives a canvas, a placement, or both; a canvas name that doesn't match an existing canvas creates one. Placements resolve in call order against the canvas as it will look after the move, so a later move may anchor to a page moved earlier in the same call; moves without a placement take the canvas default after every explicit placement. A component or page layout move gives a folder: an id or name (a name that doesn't match an existing folder creates one), or null to take it out of its folder. Folder names aren't unique, so pass the id when list_folders shows more than one folder with that name. All moves are validated together before anything changes: a bad anchor errors and nothing moves. Each filed item reports its previousFolder — pass it back as folder to revert.
Duplicate a page, component, snippet, canvas, theme, or a whole project. For a canvas, its pages are copied but its prototype is not. Duplicating a theme is the only way to add a theme, and it requires the Pro plan (theme ids come from list_themes); the copy has its own values, so editing it leaves the original unchanged (edit it with edit_theme and the returned id as themeId). A copied component lands in the same folder as the original. To copy a page and change it, duplicate it and edit the copy.
Lists design comment threads, with each thread's comments as plain text, author, and timestamps. Returns open threads by default; set includeResolved to include resolved ones. Pass a page to get its threads, a canvas to get the threads on every page placed on it, or omit id, name, and url to list threads across the whole project. Each thread's nodeId matches the data-node-id from get_page_info with includeNodeIds, so you can target the commented element with edit_page, update_node_styles, or screenshot_page; nodeId is null when the commented element was deleted. Comments exist only on pages. Replying to and resolving threads isn't supported yet; the user does that in the Subframe editor. If id, name, or url matches more than one item, the call errors and lists each match — pass an id to disambiguate.
Stages one or more files for upload into a project before adding them as assets: add_icons for SVG icons, add_fonts for WOFF/WOFF2/TTF/OTF fonts, add_images for PNG/JPEG/GIF/WebP/AVIF/SVG images. Flow: call create_asset_upload once, POST each file directly to the returned S3 url with the returned form fields, then call add_icons, add_fonts or add_images with the uploadId and each file's path. For example, to put a screenshot on a page: create_asset_upload, curl the PNG, add_images, then use the returned url as an <img> src in edit_page. Uploading requires an agent environment that can run shell commands (e.g. curl) to POST the files directly — it doesn't work from a client that can only call tools. The upload is kind-agnostic — it doesn't validate file contents; that happens when you add a file as a specific asset type (e.g. add_icons rejects a file that isn't a valid SVG, add_images rejects a file that isn't a supported image). The upload link itself accepts POSTed files for only 10 minutes after this call, but once uploaded, files stay available to add for about a day. Each file's form field "key" is keyPrefix plus that file's own path (the returned fields omit key), "file" must be the last form field, and each file must be 1 to maxFileBytes bytes. Calling create_asset_upload again mints a new uploadId — files uploaded under different uploadIds need separate add calls, one per uploadId.
Adds SVG files staged by create_asset_upload to the project's icon library. Flow: call create_asset_upload, POST each SVG with the request it returns, then call add_icons with that uploadId and the path each file was uploaded under. colorMode defaults to "monotone", which makes an icon recolorable — every shape renders in the surrounding text color at full opacity, flattening any transparency; "duotone" also recolors to the surrounding text color but keeps each shape's own opacity, so layered artwork keeps its depth; "multicolor" keeps the SVG's own colors as authored, for logos and illustrations whose colors matter. Choose it yourself rather than asking the user. name defaults to the uploaded file's name (its extension and a trailing "Icon" stripped). If it matches an existing uploaded icon, that icon is replaced in place (keeping its id, so designs already using it pick up the new artwork) rather than added as a new one. Results report each icon's final import name — the same name get_icon_info, list_icons, and search_icons use — which may carry a number suffix if the name was already taken. Gradients, masks, filters, patterns, images, text, and shapes reused through <use> or <symbol> aren't supported: they're dropped on import, and in multicolor mode a gradient fill renders black. Check an icon with get_icon_info if it matters.
Adds font files staged by create_asset_upload to the project as custom font families. Flow: call create_asset_upload, POST each font (WOFF, WOFF2, TTF, or OTF) with the request it returns, then call add_fonts with that uploadId and the path each file was uploaded under. A family name comes from the file's own name table unless family is passed, which overrides it. Files in the same call whose family names match (case-insensitively) become one family: a new family is added, or if a custom family of that name already exists in the project, its faces are updated — a file whose weight and style match an existing face replaces that face, and the family's other faces are kept. A variable font must declare a weight (wght) axis; one without it fails. Passing a family that already names a Google font in this project fails that file — use the Google font by name (e.g. in edit_theme) instead of uploading it, or pass a different family.
Adds images to the project's images, hosted on Subframe's image CDN, from image URLs or from files staged by create_asset_upload. For an image at a public URL, pass its sourceUrl; Subframe's image host fetches it, so don't download it. Pass every image URL in one call: URL imports are rate-limited per call. For a local file, or an image only your machine can reach (localhost, a private network, a signed-in page; download it first), call create_asset_upload, POST each image (PNG, JPEG, GIF, WebP, AVIF, or SVG) with the request it returns, then pass that uploadId and the path each file was uploaded under. Each image is added as a new image, named after the file or URL unless name is passed, and returns its id and url: use that exact url as an <img> src in edit_page or design code, and the design references the project image itself rather than an external URL. To refresh an image, add the new file, point each <img src> at its new url with edit_page, then optionally remove the old image with delete_images. list_images lists the project's images.
Lists the project's uploaded icons by import name, the exact name code references (e.g. <SubframeCore.Icon name="ArrowLeft" /> or <Button icon="ArrowLeft" />). Inspect one with get_icon_info and remove it with delete_icons. Built-in Lucide icons (named with a Feather prefix, e.g. FeatherCheck) aren't listed here; search_icons finds any icon, built-in or uploaded.
Lists the project's fonts: Google fonts and custom fonts added with add_fonts. Every listed font is usable by name (e.g. in edit_theme). A font weight can be any number from 1 to 1000: a variable Google font gives its range in weightRange ({ min, max }; null for a static font) beside its named weights. A custom font's faces include the URL its binary is served from.
Lists the project's images by id, name, and url. Use an image in a design by putting its url exactly as an <img> src (in edit_page or design code). Add images with create_asset_upload and add_images, and remove them with delete_images.
Looks up one or more icons by id (from list_icons or add_icons results). Pass ids as an array even for one icon: { ids: ["<iconId>"] }. For an uploaded icon, returns its import name, colorMode, and SVG markup as JSX. A built-in Lucide icon has no stored markup — reference it by name instead — and an id with no icon in this project gets its own reason. Each id is resolved independently.
Deletes one or more uploaded icons from the project's icon library. Pass ids as an array even for one icon: { ids: ["<iconId>"] }. Designs using a deleted icon lose it — the icon prop is cleared. An id whose upload had replaced a built-in Lucide icon is restored to that icon instead of removed, keeping every reference to it valid. A built-in Lucide icon can't be deleted, and an unknown id fails — each independently, without affecting the rest of the call.
Deletes one or more custom fonts, each replaced by another font (a Google or custom font id from list_fonts). Pass fonts as an array of objects, not bare ids, and give every entry its replacement: { fonts: [{ id: "<customFontId>", replacementFontId: "<fontId>" }] }. Every use of a deleted font — theme tokens, the theme's default font, and designs — switches to its replacement. A Google font can't be deleted. Entries are processed in order against the project's current state, so an entry can't use a font an earlier entry in the same call already deleted as its replacement.
Deletes one or more images from the project (ids from list_images or add_images results). Pass ids as an array even for one image: { ids: ["<imageId>"] }. Designs using a deleted image keep showing it: each reference becomes a plain URL to the same file instead of a link to the project image. An unknown id fails without affecting the rest of the call.
Renders a component's variants and interaction states and returns a screenshot so you can validate the result against the intended design. Use it after writing a component with create_component / edit_component, or once any background job writing it has finished, before considering the work complete. It renders the default desktop breakpoint unless breakpointId is provided; call get_theme to discover exact IDs for other breakpoints. Set darkMode to inspect the dark theme; each call returns output for exactly one theme. A component URL supplies its projectId automatically. One of id, name, or url must be provided.
Renders a page and returns a screenshot of it so you can see the result and check it against the intended design. It renders the default desktop breakpoint unless breakpointId is provided; call get_theme to discover exact IDs for other breakpoints. For a page taller or wider than one capture, use offsetX / offsetY to inspect later regions. Pass nodeId instead to inspect one exact element from get_page_info(includeNodeIds: true); nodeId and offsets cannot be combined. Use it after create_page / edit_page / update_node_styles on a page (or once any background job writing it has finished) to validate the rendered page before considering the work complete. A page URL supplies its projectId automatically. One of id, name, or url must be provided.
Exports a page, one element of a page, a component, or a snippet as an image file for the user and returns a download URL. Use this when the user wants an image of their design; use screenshot_page or screenshot_component to check your own work. A page renders at the default desktop breakpoint unless breakpointId is provided; call get_theme to discover exact IDs for other breakpoints. Pass nodeId from get_page_info(includeNodeIds: true) to export one exact element instead of the whole page. A component exports as one instance at its display size with no labels or variant sheet: its default variant only; screenshot_component shows every variant and interaction state. A snippet exports whole at its own content size, not as a full-height page; nodeId does not apply to it. The image is unshrunk, rendered at scale (default 2) in png (default, keeps transparency), webp (keeps transparency), jpeg (white background), or pdf (one vector page of a whole page, component, or snippet; nodeId is refused, scale is ignored, and width and height are CSS pixels). Scale is lowered for very large captures, and the result reports the scale actually used. A URL supplies its projectId automatically. One of id, name, or url must be provided.
Create or update a design document with markdown content. If id is provided, edits the existing document; otherwise creates a new one. Project docs are returned by get_project_info, and component docs are returned by get_component_info. Read those first to find ids and existing content. Component examples can be embedded via `<div data-type="component-example" data-component-id="<snippetId>"></div>` HTML syntax. Components allow at most one design document each, so always provide the existing doc id if applicable. The pinned project document (isPinned in get_project_info) is the design guidelines of the project, which Subframe always gives the AI: to change the guidelines, edit it by id instead of creating a new document.
Delete a design document, either a project document or the one attached to a component. Take the id from a fresh get_project_info (project documents) or get_component_info (component documents) — it is the id write_design_document returned, not the component's id. The pinned project document (the project's design guidelines, isPinned in get_project_info) can't be deleted: it is refused, and the user can unpin it in the Subframe editor. Deleting the document does not touch the component or snippets it mentions. Deletion is irreversible from MCP — use project version history in the Subframe editor to restore the document. Confirm with the user before deleting unless they asked for it.
Search the Subframe Docs knowledge base for information about the Subframe product and the development workflow. ## When to use - The user asks a high-level question about how Subframe or one of its features works. - The user asks about the development workflow with Subframe (e.g. taking designs to code, best practices, or troubleshooting the Subframe CLI or MCP server). - You need to verify whether Subframe supports a capability before telling the user it is not supported. Results are general Subframe documentation (titles and links), not specific to the user's project.
Search Subframe's hand-curated library of distinctive real landing pages, chosen for their visual and art direction. Use it to break away from generic defaults: every site is here because it looks unlike the typical AI-generated page. Returns matching sites with inline preview images, a visual summary, style tags, fonts, palette, and what is worth borrowing. ## When to use - Before designing a landing page, marketing page, or section, especially when the brief is generic or gives no visual direction. - When the user asks for inspiration, examples, a fresh look, or "something like X". ## How to search Describe the look you want in plain language: mood, palette, typography, layout, imagery. Be specific. Good: "warm editorial page with huge condensed type and terracotta colour blocks", "playful SaaS page with whimsical 3D illustrations". When the brief is generic, search for a distinctive visual direction that would suit it, not just the product category: "calm, warm, photography-led" finds more than "SaaS landing page". Avoid negations and combining unrelated asks (search separately). Name a site to find it directly. Use the filters only for hard requirements; you don't need to match the user's colours in the search, since you will apply them yourself. ## Using results These sites are art direction, not wireframes. Examine the inline images to judge each site's actual design; don't work from the metadata alone. - Pick one site whose direction suits the brief and commit to it: carry over its palette, type pairing and scale, layout devices, and imagery treatment. Don't average several results, and don't fall back to the usual centered hero, gradient, and three feature cards. The result should look clearly different from what you would have made without it. - The user's explicit requirements always win. If they ask for a green accent, serif headings, or their own brand colours, keep those and adapt the reference around them: carry over its palette structure (contrast, how much colour, where the accent appears) in their colours, and keep the rest of its direction. The reference fills in what the user left open; it never overrides what they asked for. - Borrow the visual system, not the content: never copy a site's copy, logos, or brand assets. - Inline images are low-resolution previews for you; the reference image URLs are full resolution, for saving, sharing, or passing to image-capable tools. Cite each site you mention with its live site URL.
Search the Subframe Motion Library for React animation examples. Describe what you want in plain words — the effect, the element, how it should feel, or, when matching a screenshot, what it looks like and what moves ('glowing border sweeping around a dark pricing card', 'playful press feedback for a like button', 'calm shader background behind a headline'). Results come most relevant first, with how each one looks; call get_motion_example with a slug for its code. If nothing fits closely, the result says so. Search reads plain language but not negations, so put hard constraints in the filters (runtime react means no animation library). Leave the query empty to browse a category or runtime.
Get one Subframe Motion Library example: its complete React source; how it looks and moves; adapt notes naming the code that drives the motion and what to change; the npm packages to install (none means React only); the images its code loads from /motion/assets/ with download URLs (serve them there or change the paths); reduced-motion behavior and limitations; its licence and upstream credit; related examples; the guidance topics worth reading; and a preview image. Use a slug from search_motion_examples or from a www.subframe.com/motion/<slug> URL. This writes no files: adapt the code to the project, keep its licence header, and test it there. The code targets React 19; with React 18 server rendering, move its inline <style> CSS into a stylesheet, since React 18 escapes the CSS's quotes and > characters.
Get Subframe's guidance for designing motion well, by topic: principles (whether to animate at all), timing (durations, curves, springs), enter-exit (menus, dialogs, toasts), feedback (hover, press, state, loading), scroll, ambient (loops, backgrounds, shaders), text-and-numbers, performance, accessibility and adapting (turning a library example into project code). Read the relevant topics before designing, adapting or reviewing any animation, not only library examples.
Generates a CLI auth token for the authenticated user. Use this token with the Subframe CLI (e.g. `npx @subframe/cli init --auth-token <token>`). The token is scoped to a specific team.
Lists the prototypes in a project. A prototype is an interactive, AI-built running app (its own React/Vite codebase) created in the Subframe prototyping editor. Pass an id from this list to get_prototype_info or read_prototype_file.
Gets information about a single prototype, including the list of files in its standalone, runnable Vite app. Pass an id from list_prototypes. Read individual files with read_prototype_file.
Reads the contents of a single file from a prototype's standalone, runnable Vite app. Use the file paths returned by get_prototype_info.
Report a problem with Subframe's MCP tools to the Subframe team (not to the user's project or teammates). Call it at most once per task, and only when: - you couldn't do what the user asked because a Subframe tool was missing, confusing, or kept failing after you corrected your call, or - the user asks you to send feedback to Subframe. Skip it when the task went fine or when you fixed your own call. Never use it to log progress, to test it, or as a way to end your turn. In the description, name the project and include the failing call's arguments and error. Leave out secrets and personal data, and describe people by role.
Tell Subframe you are done working on a project, so collaborators with it open see you have finished. Call it once when you finish a task that read or changed the project, before your final reply. Any later Subframe call marks you as working again.