Cursor Talk to Figma MCP
Server Quality Checklist
Latest release: v0.2.1
- Disambiguation4/5
Most tools target distinct resources and actions (e.g., set_padding vs. set_item_spacing). However, get_selection and read_my_design both describe getting selection info with subtle differences, and get_node_info vs. get_nodes_info could confuse agents.
Naming Consistency4/5The vast majority follow a consistent verb_noun snake_case pattern (get_, set_, create_, delete_, etc.). Minor deviations like read_my_design and the multiple batch variants (set_multiple_*) break the pattern slightly.
Tool Count2/5With 38 tools, this server is well beyond the typical 3-15 tool range. While Figma is a complex domain, this many tools feels heavy and could overwhelm agents, making selection harder.
Completeness4/5The tool set covers a broad range of Figma operations: node CRUD, text, frames, components, styles, layout, annotations, exports, and prototyping reactions/connections. Some niche operations like style creation or component updates are absent, but core workflows are well covered.
Average 3.4/5 across 38 of 38 tools scored. Lowest: 2.6/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 0 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
Add a LICENSE file by following GitHub's guide. Once GitHub recognizes the license, the system will automatically detect it within a few hours.
If the license does not appear after some time, you can manually trigger a new scan using the MCP server admin interface.
MCP servers without a LICENSE cannot be installed.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add
glama.jsonto the root of your repository:{ "$schema": "https://glama.ai/mcp/schemas/server.json", "maintainers": [ "your-github-username" ] }Then . Browse examples.
Add related servers to improve discoverability.
How to sync the server with GitHub?
Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.
To manually sync the server, click the "Sync Server" button in the MCP server admin interface.
How is the quality score calculated?
The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).
Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.
Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).
Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.
Tool Scores
- Behavior1/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full behavioral transparency burden. It only states the valid node types but fails to disclose critical behavior such as whether the fill is replaced or appended, what happens if the node has multiple fills, or how the alpha channel behaves when not specified. This is a significant gap for a mutation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single short sentence and front-loads the main action, but the sentence is grammatically incomplete ('can be TextNode or FrameNode' is a fragment). It could be more polished, but it is concise and does not contain unnecessary filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 5-parameter mutation tool with no annotations and no output schema, the description is too minimal. It does not mention side effects, prerequisites, what the result looks like, or any error conditions. The node type restriction is helpful but insufficient for an agent to fully understand the tool's impact.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already describes all five parameters (nodeId, r, g, b, a) with full coverage. The description adds no additional meaning to the parameters. Since schema coverage is 100%, the baseline score of 3 is appropriate; the description does not need to explain parameters further.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the action (Set the fill color) and the target resource (a node in Figma), and even specifies valid node types (TextNode or FrameNode). However, the grammar is awkward and incomplete, which prevents a perfect score. It still distinguishes itself from siblings like set_stroke_color by focusing on fill color.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided about when to use this tool versus alternatives. It does not mention that it should be used for fill colors specifically as opposed to stroke colors, borders, or other properties. The usage context is only implied by the tool name, not explicitly stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description bears the full burden for behavioral disclosure. It only says 'Create an instance' without stating that this mutates the document, whether a loaded file is required, what the return value is, or any coordinate system assumptions. This is a significant gap for a creation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5Is the description appropriately sized, front-loaded, and free of redundancy?
The description is seven words long and wastes no words. However, it is essentially a restatement of the tool name with 'in Figma' appended, adding minimal new information. Still, its brevity is appropriate and it is front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 3 required parameters, no annotations, and no output schema, the description is too sparse. It omits crucial operational context such as return value, coordinate space, and how to obtain a componentKey, and it does not position the tool among the many sibling editing operations.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema descriptions cover 100% of parameters ('X position', 'Y position', 'Key of the component to instantiate'), so the description need not repeat them. The baseline of 3 applies because the description adds no additional semantic depth such as coordinate units or instructions on sourcing the componentKey.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb+resource ('Create an instance of a component') and mentions the context 'in Figma', which clearly conveys the tool's function. However, it does not distinguish from sibling creation tools like create_frame or create_text beyond the component-instance target, so it falls short of a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives, no prerequisites for obtaining a componentKey, and no mention of how to position the instance. There is no contrast with siblings like create_frame or clone_node, so the agent gets no decision support.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It only says 'Create a new frame' which implies a mutating side effect, but does not mention what the tool returns, whether it requires authentication, whether it appends to a parent, or any other behavioral details. This is minimal disclosure for a mutation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, succinct sentence with no wasted words, making it highly concise. However, given the tool's complexity (20 parameters), the extreme brevity could be considered under-specification, but it remains free of fluff and is easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
This is a complex tool with 20 parameters, six enums, nested objects, and no output schema. The description is only one sentence, which does not explain return values, the role of optional parameters like parentId and layoutMode, or any side effects. The schema covers parameter meaning but not overall tool behavior, leaving the description incomplete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% parameter description coverage, so the baseline is 3. The tool description itself adds no parameter information beyond what's in the schema, but the schema already documents all parameters including nested objects and enums.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb+resource ('Create a new frame in Figma') that clearly identifies the tool's function and the object type. It distinguishes itself from sibling creation tools like create_rectangle or create_text by naming the frame resource, though it does not explicitly discuss alternatives.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives, no prerequisites, and no context about workflow. It simply states the action without explaining scenarios where creating a frame is appropriate or how it relates to other creation/modification tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It explicitly says 'Delete', which implies a destructive operation, but it does not disclose consequences such as deletion of child nodes, permanence, undo behavior, or required permissions. This is a significant gap for a mutation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence with no redundant words. It is front-loaded with the action and resource, making it easy to parse. For a simple one-parameter tool, the length is appropriate.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given that this is a destructive deletion tool with no annotations and no output schema, the description is too sparse. It fails to mention single-node scope (versus 'delete_multiple_nodes'), side effects, or any prerequisites. The minimal information leaves an agent uncertain about important usage details.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema provides a full description of the single parameter 'nodeId' (100% coverage). The tool description adds no additional parameter semantics beyond what the schema already states, so a baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5Does the description clearly state what the tool does and how it differs from similar tools?
The description states a clear action ('Delete a node') and resource ('from Figma'), making it obvious what the tool does. However, it does not differentiate from the sibling tool 'delete_multiple_nodes', which also deals with deletion. Adding 'single' or 'one' would distinguish it.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. The sibling tool 'delete_multiple_nodes' suggests batch deletion, but the description does not mention this distinction or any other usage context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden of behavioral disclosure. 'Resize a node' only implies a change in dimensions without revealing details about how the node's position, constraints, or children are affected. The description offers no insight into side effects or requirements.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence with no filler words and immediately front-loads the core action. It is appropriately concise given the tool's simplicity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description lacks necessary context for correct use, especially with no output schema or annotations. It does not explain units, coordinate system, or how resizing interacts with layout constraints. For a tool with three required parameters, this is insufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description itself adds no parameter-specific meaning; it simply states the action. All parameter semantics are adequately captured by the input schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb 'resize' and resource 'node', clearly indicating the operation. It is distinguishable from sibling tools like move_node or set_layout_sizing, though it does not explicitly differentiate itself from those alternatives.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. The description does not mention when resizing is appropriate, what prerequisites exist, or how this differs from related operations such as moving or layout adjustments.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full behavioral disclosure burden. It merely says 'create or update' without revealing key traits such as upsert behavior, whether annotationId is required for updates, or what happens if no annotationId is supplied, creating ambiguity.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, succinct sentence that front-loads the core action. It is efficient, though for a tool with five parameters it could benefit from a bit more context while remaining concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With five parameters, create/update semantics, no output schema, and no annotations, this description is far from complete. It does not explain the distinction between create and update flows, required parameters for each path, or any side effects.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description adds no extra meaning about parameter relationships (e.g., that annotationId is needed for updates or categoryId for creation), but the schema already documents each parameter individually.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('create or update') and resource ('annotation'), making the core purpose understandable. However, it does not explicitly differentiate this from the sibling tool 'set_multiple_annotations', which also deals with annotations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like 'set_multiple_annotations' or 'get_annotations'. It also fails to mention prerequisites or context, leaving the agent to infer when this tool is appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full responsibility for behavioral disclosure. It mentions 'parallelly' suggesting concurrency, but does not explain potential side effects, atomicity, failure handling, or whether annotations are created or updated (especially since `annotationId` is in the schema for updates). This leaves significant behavioral uncertainty.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence, front-loaded with the action and object. It is concise with no wasted words, though 'parallelly' is an awkward adverb that could be replaced with 'in parallel' without losing meaning. Overall, it is structurally efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given there is no output schema and no annotations, the description should provide more context about return values, validation, and operational behavior. The tool performs a batch operation with potential partial-failure scenarios, but the description gives no hint of these complexities. The result is insufficient for an agent to fully anticipate outcomes.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema covers 100% of parameters with descriptions, so the baseline is 3. The description itself adds no parameter-level context, and notably does not clarify the relationship between the top-level `nodeId` and the per-item `nodeId` in the annotations array—a potential source of confusion. Since the schema already handles semantics, this is acceptable but not enhanced.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: setting multiple annotations at once within a node. It uses a specific verb ('set') and resource ('annotations'), and distinguishes from the sibling tool `set_annotation` by emphasizing 'multiple'. However, 'parallelly' is slightly ambiguous and not a standard term.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no explicit guidance on when to use this tool versus alternatives like `set_annotation` or `get_annotations`. It only implies usage through the name and the word 'multiple', but does not mention advantages, prerequisites, or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden for disclosure. It only mentions 'parallelly', hinting at concurrent execution, but fails to disclose effects such as whether existing text is replaced, whether the operation is atomic, or if special permissions are needed. This is a significant gap for a mutation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise, using a single sentence that front-loads the action. However, the word 'parallelly' is non-standard and slightly awkward, which slightly reduces clarity. Overall, it is efficient with no wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a batch operation with two parameters, no output schema, and no annotations, this description is under-specified. It lacks context about return values, failure modes, or behavior on partial failures. A richer description would be needed to fully guide an agent in using this tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so parameters are already well-documented. The description adds no additional semantic value about parameters (e.g., that 'nodeId' is the parent container and 'text' is an array of child node-specific replacements). The baseline of 3 applies since the schema handles the explanation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's action: setting multiple text contents within a node. It uses a specific verb ('set') and resource ('text contents'), and the word 'multiple' differentiates it from the sibling tool 'set_text_content'. However, 'parallelly' is an unusual adverb that could confuse, but the core purpose is clear.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives like 'set_text_content'. It does not explicitly state that this should be used when updating several text nodes at once, nor does it mention any exclusions or prerequisites. The user is left to infer usage from the name and schema.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of disclosing behavior. It implies read-only ('get') and operation on the 'current' document, but it does not describe the return format, depth of information, or any requirements. This is minimal transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence that is front-loaded with the action and resource. It is appropriately sized for a tool with no parameters, though it could add a few clarifying words without becoming verbose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the absence of an output schema and annotations, the description should explain what 'detailed information' includes (e.g., document name, pages, settings). It does not, and for a tool that returns document-level data, this is a significant gap, especially when compared to the richer descriptions of sibling tools.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so the schema provides complete coverage. The description correctly does not attempt to describe parameters, and the baseline for no-parameter tools is 4, which is appropriate here.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the tool as retrieving document-level information ('current Figma document'), which distinguishes it from sibling tools like get_node_info and get_selection that target nodes or selections. However, the phrase 'detailed information' is vague and does not specify what aspects of the document are covered.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. The description does not mention any exclusions or point to sibling tools for node-specific or selection-specific queries, leaving the agent to infer usage entirely from the tool's name and purpose.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior1/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description must carry the full burden of behavioral disclosure. It only restates the name and domain ('Create a new rectangle in Figma') and does not mention side effects, default parent behavior, mutation, permissions, or reversibility. This adds no value beyond the purpose clarity.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence with no redundancy. It front-loads the core purpose effectively, and every word earns its place, making it appropriately sized for a simple creation tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description alone is minimal but sufficient for a basic create operation given the schema covers all parameters. However, it lacks context about default behaviors (e.g., what happens if parentId is omitted) and does not enrich the overall workflow. It is a minimum viable description.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all parameters (e.g., x, y, width, height, name, parentId). The description adds no parameter semantics beyond the schema, meeting the baseline of 3 as the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5Does the description clearly state what the tool does and how it differs from similar tools?
The description uses the specific verb 'Create' with the resource 'rectangle' and context 'Figma', clearly distinguishing it from sibling tools like create_frame or create_text. The purpose is unambiguous and directly tied to the tool's name.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to choose this tool over alternatives such as create_frame or create_text. The description only states the action without contextual use cases, exclusions, or comparisons to sibling creation tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It does not mention side effects (e.g., whether it replaces existing stroke colors), permissions, error conditions, or return values. For a mutation tool, this is a significant gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single efficient sentence that earns its place. It is not overly verbose, though it could be slightly more informative without becoming bloated.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a mutation tool with no annotations and no output schema, the description is insufficient. It does not explain what happens after the stroke color is set, whether the node must have a stroke, or any other behavioral context. The schema covers parameters, but return values and edge cases remain undocumented.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all parameters (nodeId, r, g, b, a, weight). The description adds no parameter-specific meaning, but per the rubric baseline 3 applies when schema coverage is high.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states a specific action ('Set') on a specific resource ('stroke color of a node in Figma'). It distinguishes from siblings like set_fill_color by explicitly naming 'stroke color'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives such as set_fill_color, nor are any prerequisites or constraints mentioned. The description only states what it does, not when or when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full responsibility for behavioral disclosure. It only states the basic action ('create') and reveals nothing about return values, side effects, permissions, or how it interacts with the document. This is a minimal but non-misleading disclosure.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, short, grammatically complete sentence with zero filler. It efficiently communicates the tool's purpose without unnecessary detail, matching the standard for appropriate conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has 8 parameters including a nested fontColor object and no output schema, yet the description provides no context about return values, default behavior, parent requirements, or typical use scenarios. The single-sentence description is insufficient for an agent to fully understand the tool's behavior in complex workflows.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so all 8 parameters (x, y, text, name, fontSize, parentId, fontColor, fontWeight) have individual descriptions. The tool description adds no additional parameter meaning, so the schema already provides the needed semantics. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb ('Create') and resource ('text element') with clear scope ('in Figma'). It distinguishes from sibling tools like set_text_content (which modifies) and create_rectangle (which creates a different resource type).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. It doesn't mention that set_text_content should be used for modifying existing text, or any context about parent frames or prerequisites. The description simply states what it does without guiding selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure, but it only states the core action. It does not disclose whether the tool returns binary data, a URL, or a file path, nor does it mention permissions, side effects, or limitations on node types. This is a significant gap for a tool with no annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no unnecessary words. It effectively communicates the core purpose without fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has no output schema and no annotations, so the description must explain what the agent should expect after invocation. It does not mention the response format, return value, or any constraints on the export. Given the tool's simplicity in parameters, this lack of contextual detail is a clear gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description adds no extra meaning beyond the schema; the schema already documents each parameter adequately (nodeId, scale, format). The description does not compensate for any ambiguity.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Export'), the resource ('a node'), and the result ('as an image from Figma'). It is specific and distinguishes this tool from all sibling tools, which focus on other operations like setting, getting, or creating nodes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives, no exclusions, and no context about typical scenarios. It does not mention which node types are exportable, how scale or format affect usage, or when to prefer another tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behavior itself, but it only says 'scan'. It does not clarify whether the operation is read-only, what it returns, how deep the scan goes, or how 'selected' relates to the nodeId. This ambiguity is a significant gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear, front-loaded sentence. Every word contributes to the core purpose with no redundancy or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the absence of an output schema and annotations, the description should explain what 'scan' yields (e.g., list of node IDs, text values) and whether the scan is recursive. It also leaves the 'selected' vs. 'nodeId' relationship unclear, making the tool incomplete for an agent to use confidently.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema already fully documents nodeId as 'ID of the node to scan'. The description adds only the word 'selected', which slightly narrows the context but does not provide meaningful additional semantics beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states a specific action ('scan') applied to a specific resource ('all text nodes') within a given scope ('selected Figma node'). This distinguishes it from sibling tools like set_text_content or scan_nodes_by_types.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. There is no mention of prerequisites, exclusions, or context such as how the selected node relates to the nodeId parameter.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations available, the description bears full responsibility for behavioral disclosure. It only states the basic action, omitting details like whether children are copied, if the clone gets a new ID, or any side effects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that conveys the core purpose without any wasteful words. It is appropriately concise for a simple tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple clone operation with only three parameters and no output schema, the description is minimally adequate. However, it lacks information about return values or default behavior (e.g., what happens if x/y are omitted), which would make it more complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so parameters are already fully documented. The description adds no additional parameter-level context beyond what the schema provides, earning the baseline score.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb 'Clone' with the resource 'an existing node in Figma', clearly distinguishing it from sibling tools like move_node or resize_node. There is no ambiguity about the tool's primary action.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives, such as create_rectangle or create_component_instance. No exclusions or preferred contexts are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of disclosing behavioral traits. It only states the action but does not disclose side effects, whether joining requires an existing channel, whether it modifies state, whether it can be undone, or what happens after joining. This is a significant gap for a state-changing operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence that front-loads the core action. It has no filler or redundant information, and it is appropriately sized for a tool with one parameter.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with one parameter and no output schema, the description provides the basic function but lacks context about what a 'channel' is in Figma, what communication entails, and any behavioral details. Given the tool's simplicity, the description is adequate but not complete, leaving a notable gap in understanding the tool's role in the overall workflow.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already provides 100% coverage for the only parameter, describing 'channel' as 'The name of the channel to join'. The description adds nothing beyond the schema, using the word 'specific' without providing additional meaning. Thus, the score is at the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Join a specific channel to communicate with Figma' clearly names the action (join) and the resource (channel), and implies a purpose. It distinguishes itself from sibling tools by focusing on the channel concept, which none of the siblings mention. However, the exact nature of the channel (e.g., comment feed, plugin communication) is left undefined, so it is not fully explicit.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the usage context (you join a channel to communicate with Figma) but does not explicitly state when to use this tool versus alternatives, nor does it mention any prerequisites or conditions. There are no alternative join tools among siblings, which reduces the need for exclusions, but the description still lacks concrete guidance on when the tool is appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full responsibility for disclosing behavioral traits. It states what is changed (layout mode and wrap) but omits side effects, such as whether existing children are rearranged, whether the frame must already be a frame/auto-layout, or whether setting NONE disables auto-layout entirely. The optional layoutWrap behavior is also left implicit.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence that immediately states the verb and target. No wasted words or redundant information. Front-loaded and easy to scan.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple setter tool with a fully self-explanatory schema, the description covers the basics. However, it lacks usage context and behavioral caveats (e.g., what 'wrap behavior' means visually or how layoutMode NONE interacts with children). Given no annotations or output schema, the description could have added a bit more context to reach full completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all three parameters (nodeId, layoutMode, layoutWrap) with meaningful descriptions and enums. The description adds no extra semantic meaning beyond what the schema provides, but it also does not need to, hence baseline 3.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Set') and names the exact resource ('layout mode and wrap behavior of a frame'). It clearly distinguishes from sibling tools like set_layout_sizing or set_item_spacing, which target different aspects of layout.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool vs. alternatives. The description merely states the action without providing context, prerequisites, or exclusions. For example, it does not mention that this is for frames with auto-layout enabled or that set_layout_sizing handles sizing dimensions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
There are no annotations, so the description carries the burden of disclosing behavioral traits. It does not mention side effects, constraints, error handling, or what happens if the target node is not an auto-layout frame. The only hint is that the target is an auto-layout frame, but this is more a target description than a behavioral disclosure.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5Is the description appropriately sized, front-loaded, and free of redundancy?
A single, compact sentence that conveys the tool's purpose without extraneous details. It is well-structured and front-loaded, making it easy for an agent to quickly understand the action.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is a simple setter with 3 well-described parameters and no output schema. The description is adequate for basic use but lacks details about failure modes, prerequisites (e.g., node must be an auto-layout frame), or interactions with other layout settings. Given the simplicity, it meets the minimum viable threshold.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with each parameter fully described (nodeId, layoutSizingVertical, layoutSizingHorizontal) including enum constraints and special conditions (e.g., HUG for frames/text only, FILL for auto-layout children). The description adds no additional parameter semantics beyond what the schema already provides, so the baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Set') and the resource ('horizontal and vertical sizing modes for an auto-layout frame in Figma'). This distinguishes it from sibling tools like set_layout_mode, which focuses on layout direction rather than sizing modes. The mention of both horizontal and vertical adds specificity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided about when to use this tool versus alternatives. It does not mention that this is specifically for auto-layout frames (though implied) or that it complements set_layout_mode or set_padding. No exclusions or alternative tool mentions exist.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It only says 'get detailed information' without specifying read-only nature, return structure, potential errors, or any limitations. It adds minimal value beyond the tool's name and schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence that front-loads the action ('Get') and resource ('detailed information about a specific node in Figma'). No unnecessary words or repetitive content.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the absence of an output schema and annotations, the description is too vague. It does not explain what 'detailed information' includes, nor does it clarify how this tool differs from get_nodes_info or handle error cases. Leaves significant ambiguity for an agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% for the single nodeId parameter. The tool description adds no additional meaning about the parameter, such as format or how to obtain it, so it stays at the baseline for full schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: it retrieves detailed information for a specific node. The phrase 'a specific node' distinguishes it from sibling tools like get_nodes_info (plural) and get_document_info, making the purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides a clear context—use when you need info about a single node—but it does not explicitly mention when not to use it or point to alternatives like get_nodes_info. The usage is implied rather than explicitly stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden for behavioral disclosure. It indicates this is a read operation ('Get information') but does not mention edge cases such as an empty selection, what data is returned, or any potential side effects, though for a simple get tool this is somewhat sufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence that is front-loaded with the action and resource. Every word earns its place, and there is no extraneous information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter read tool with no output schema, the description is minimally adequate by stating the tool's purpose. However, 'information about the current selection' is vague, and without an output schema, the agent cannot anticipate what specific data will be returned, which is a slight gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has zero parameters, so the baseline for this dimension is 4. The description adds context by specifying the 'current selection' as the implicit subject, which is useful but not necessary for parameter understanding.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a clear verb ('Get') and resource ('information about the current selection in Figma'), making its purpose obvious. However, it does not differentiate from sibling tools like get_node_info or get_nodes_info, though 'selection' is a distinct concept.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives, nor does it mention any prerequisites or exclusions. Usage is only implied by the tool's name and basic purpose, which is insufficient.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry the full burden of behavioral transparency. It only states the action of setting a default connector, without disclosing side effects, whether the operation is reversible, what happens to the previous default, or any permission requirements. For a mutating operation, this is insufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no redundant wording. It communicates the purpose and the key condition (copied connector) efficiently.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has no annotations and no output schema, the description is too thin. It does not explain what 'default connector' means, how the operation affects other connectors, or what the expected result is. A simple mutation tool still needs more context to be safely invoked by an agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema covers 100% of the parameter (connectorId) with a clear description. The tool description adds the crucial constraint that the node must be a 'copied' connector node, enriching the schema's meaning. However, the schema lists required parameters as 0, and the description does not clarify that connectorId is likely mandatory, so the added value is moderate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb 'Set' and identifies the resource as 'a copied connector node' and the outcome 'as the default connector'. This clearly distinguishes it from sibling tools, which mostly target styling, layout, or node operations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'Set a copied connector node as the default connector' implies usage when a copied connector exists and you need it to become the default. However, there is no explicit guidance on when to use this tool versus alternatives, nor any exclusions or prerequisites. Since no sibling tool handles connector defaults, the implied context is sufficient but not explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses that connections are created with the default connector style, but doesn't specify side effects (e.g., whether existing connections are preserved, whether nodes must be valid, or any state changes). It omits information about return values or error behavior, leaving the agent uncertain about the tool's behavior beyond the basic create action.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence with no filler. It front-loads the core purpose and the key constraint (default connector style). Every word contributes to understanding the tool's function, making it highly efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (one parameter, no output schema) and complete schema coverage, the description covers the essence but lacks usage guidance and behavioral transparency. It doesn't mention that multiple connections can be created at once or any prerequisites (e.g., existing nodes), but these are partly inferable from the schema. Overall, it is adequate but not comprehensive.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema provides 100% coverage for the lone 'connections' parameter, with descriptions for each nested property (startNodeId, endNodeId, text). The description adds no parameter-specific semantics beyond saying connections are between nodes, so the baseline score of 3 applies as the schema fully documents the parameter.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action (create connections) and the resource (nodes), and specifies the style ('using the default connector style'), which distinguishes it from sibling tools like set_default_connector. It is a specific verb+resource statement with no ambiguity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage (create connections when you want to link nodes with the default style) but provides no explicit when-to-use vs alternatives, no exclusions, and no mention of related tools like set_default_connector for customizing style. It gives a clear purpose but lacks guidance on when this is the right choice compared to other connection-related tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden for behavioral disclosure. It merely restates the delete action without mentioning irreversibility, effects on child nodes, permission requirements, or limits. For a destructive operation, this is insufficient transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, short, front-loaded sentence with no filler. It efficiently communicates the action and scope without unnecessary words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple with one parameter and no output schema, so the description needn't explain return values. However, it omits behavioral context such as error handling, effects on child nodes, or any limits. It is minimally complete but lacks ancillary detail that would make it fully informative.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% for the single parameter nodeIds. The description adds no new semantic detail beyond the schema, and the 'multiple' qualifier is redundant with the array type. Baseline 3 applies because the schema fully documents the parameter.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool deletes multiple nodes from Figma at once. 'Multiple' distinguishes it from the sibling delete_node, and the verb 'delete' plus resource 'nodes from Figma' make the purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit when-to-use guidance or mention of alternatives. The 'multiple' qualifier implies it is for batch deletion, and the existence of sibling delete_node suggests a choice, but the description does not state when to prefer one over the other. Usage is implied rather than stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full responsibility for behavioral disclosure. It only states that the tool 'gets' annotations, revealing nothing about return format, potential side effects (e.g., read-only), or error behavior. This is insufficient for a tool without annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no filler. Every word carries meaning, clearly conveying the action and scope.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple getter with two optional parameters and no output schema, the description gives the essential purpose but omits details about the return structure or how categories are represented. Given the lack of annotations and output schema, a bit more context would improve completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already provides 100% coverage for both parameters (nodeId and includeCategories) with descriptive texts. The tool description adds no additional parameter insights, so it neither compensates for gaps nor enhances understanding beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function with a specific verb ('Get') and resource ('annotations'), and further specifies scope ('in the current document or specific node'). This distinguishes it from sibling write tools like set_annotation and set_multiple_annotations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for retrieving annotations from either the whole document or a specific node, but it does not explicitly state when to prefer this over alternatives (e.g., get_reactions) or mention any exclusions. Sibling tools are not referenced.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description bears the full burden of behavioral disclosure. It identifies this as a read operation ('get') but does not explain what 'local components' entails, return format, or any potential limitations. Minimal beyond the literal statement.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no filler. Every word contributes to the purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description is adequate for a simple getter, but without an output schema it leaves the return value unspecified. It also does not clarify whether 'local components' includes nested components or component properties, which could be ambiguous. However, for a fairly simple tool it is minimally sufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, and the schema is fully covered. The description adds no parameter-specific meaning, but none is required since there is nothing to configure. Baseline for 0 params is 4.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5Does the description clearly state what the tool does and how it differs from similar tools?
The description uses the specific verb 'get' and the resource 'local components,' clearly distinguishing it from sibling tools like get_styles and get_document_info. It also scopes to 'the Figma document,' making the purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. The description simply states what it does without exclusions or references to sibling tools, leaving the agent to infer usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description carries the full burden for behavioral disclosure. It states the mutation ('Set') but does not disclose side effects, behavior when 'corners' is omitted, node type restrictions, or whether the operation replaces or modifies existing corner radius values. This is a significant gap for a write operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence with no unnecessary words. It is front-loaded and appropriately concise for the tool's simplicity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple and the schema covers all parameters, but the description lacks any mention of return values, default behavior for the optional 'corners' parameter, or edge cases. Given the lack of annotations and output schema, it is adequate but leaves clear gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, meaning all three parameters are already well-documented. The description adds no additional meaning beyond what the schema provides, so the baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Set') and resource ('a node in Figma') with the exact property ('corner radius'), clearly distinguishing this from sibling tools like set_fill_color or set_padding. It unambiguously states what the tool does.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance is provided on when to use this tool versus alternatives. Usage is implied by the name and description, but there are no exclusions, prerequisites, or alternative recommendations, leaving the agent to infer the intended context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It merely states the action without revealing whether padding values are merged or replaced, what happens if the node is not an auto-layout frame, or any side effects or failure modes.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that conveys the core purpose without any wasted words. It is appropriately sized for the tool's simplicity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The schema covers parameter meanings, and the description states the purpose, but critical behavioral details (merge vs replace, error handling) are missing. For a mutation tool with no output schema, this is adequate but not fully complete for safe autonomous use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already describes all parameters in full (100% coverage), so the description adds little beyond identifying the target as an auto-layout frame. It does not clarify the relationship between parameters (e.g., setting only one side).
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Set') and resource ('padding values') with a clear target ('auto-layout frame'), distinguishing it from sibling tools like set_item_spacing or set_corner_radius. It unambiguously states the tool's function.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool is only for auto-layout frames, giving some context, but it does not explicitly state when to use this tool over alternatives or when not to use it. No exclusions or alternative tool references are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must disclose behavioral traits. It only states that the node must be existing, without detailing mutation effects, reversibility, permissions, or return values. This is insufficient for a write operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5Is the description appropriately sized, front-loaded, and free of redundancy?
A single concise sentence with no superfluous content, front-loading the action. It is appropriately sized for the tool's simplicity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple setter with fully documented parameters, the description is minimally viable but lacks information on results, errors, or related tools, especially given no annotations. It is adequate but with clear gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already provides full descriptions for both parameters (text and nodeId), so the description adds little beyond confirming the node must be a text node. Baseline 3 applies due to 100% schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the action (set), the target resource (text content of an existing text node), and the context (Figma). It distinguishes from sibling tools like set_multiple_text_contents (singular vs. plural) and create_text (existing vs. new).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool is for modifying an existing text node, which distinguishes it from creation tools. However, it does not explicitly mention when to use it over set_multiple_text_contents or provide alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of disclosing behavioral traits. The verb 'Move' implies a mutation (change of position), and the schema adds coordinates, but the description does not mention side effects, reversibility, or return behavior. It conveys the core action but lacks contextual detail such as whether the move is absolute or relative, or if it affects child nodes. This is adequate but not rich.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, well-structured sentence with no filler. It immediately states the action and target, earning its place without redundancy. This is an exemplary concise description.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple three-parameter tool with full schema coverage and no output schema, the description is mostly complete. It identifies the operation and the resource, and the schema covers parameters. However, with no annotations, it could have added a note about mutation or side effects, but the simplicity of the operation makes the current level sufficient. A small gap exists in not mentioning what happens after the move (e.g., return value or undo behavior).
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with each parameter having a clear description ('New X position', 'New Y position', 'The ID of the node to move'). The tool description adds no additional meaning beyond what the schema already provides. Since the schema fully documents the parameters, a baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Move') with a clear resource ('a node') and context ('to a new position in Figma'). It clearly distinguishes from sibling tools like resize_node, clone_node, and delete_node by specifying the action of repositioning. The schema confirms x/y coordinates, so there is no ambiguity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no explicit guidance on when to use this tool versus alternatives, nor does it mention prerequisites or exclusions. While the name and verb imply its use for repositioning nodes, it does not state scenarios where it should be preferred over other node manipulation tools. Without this, the agent must infer usage from the name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description conveys a read-only scan behavior but does not disclose whether it recurses through nested children, the return format, or any selection context dependency. The phrase 'selected Figma node' may be misleading since a nodeId is required.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5Is the description appropriately sized, front-loaded, and free of redundancy?
One sentence, front-loaded with the action, no filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description is minimal and does not explain the return value or recursion behavior, which is needed given there is no output schema. It may be sufficient for simple use but leaves key behavior unspecified.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so descriptions already define both parameters. The tool description adds marginal context ('selected Figma node') but does not enrich parameter meaning beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool scans for child nodes with specific types within a given Figma node, using a specific verb and resource. It distinguishes from sibling tools like scan_text_nodes by being type-parameterized.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool is for finding child nodes of specified types but does not explicitly compare with alternatives like scan_text_nodes or when to prefer this tool. No exclusions or alternative mentions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the basic action but does not mention potential side effects, error conditions (e.g., if the frame is not auto-layout), or any interaction with other layout properties like primaryAxisAlignItems. This leaves significant behavioral aspects undisclosed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that front-loads the verb and resource, with no extraneous words or repetition. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple setter with two fully-documented parameters and no output schema, the description covers the essential purpose. The schema already provides detailed parameter notes (e.g., the SPACE_BETWEEN interaction), so the description does not need to repeat them. It lacks only minor context about preconditions or failure behavior, which would push it to a 5.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with both nodeId and itemSpacing fully described in the schema. The description's phrase 'distance between children' paraphrases itemSpacing but adds no additional semantic value beyond the schema. The baseline of 3 is appropriate since the schema already handles parameter documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Set') and clearly identifies the resource ('distance between children in an auto-layout frame'). It distinguishes itself from sibling tools like set_padding or set_axis_align by targeting the item spacing property specifically.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'in an auto-layout frame' implies the tool applies only to auto-layout frames, giving some context. However, it does not explicitly state when to use this tool versus alternatives, nor does it mention any exclusions or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. The verb 'Get' indicates a read-only operation, which is somewhat transparent, but it does not disclose any limitations, error behavior, or what 'detailed information' specifically includes. It is minimally adequate but lacks depth.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence with no wasted words. It is front-loaded with the verb and resource, making it easily scannable for an agent.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple one-parameter tool with no output schema, the description provides the essential purpose. However, it does not mention return values, any limits on the number of node IDs, or how it differs from get_node_info beyond the plural. It is adequate but could be more complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema covers the single parameter (nodeIds) with a clear description ('Array of node IDs to get information about'), and the tool description aligns with this. However, the description adds no additional semantic meaning beyond the schema, so a baseline score of 3 is appropriate given 100% schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Get') and resource ('detailed information about multiple nodes in Figma'), clearly distinguishing it from the sibling tool get_node_info by explicitly stating the plural scope. It is precise and unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when multiple nodes need information, but does not explicitly mention when to use this tool versus alternatives like get_node_info or scan_nodes_by_types. There are no explicit exclusions or alternative references; guidance is only inferred from the plural wording.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It implies a read-only operation ('Get') and specifies the scope ('current Figma document'), but it does not disclose potential response size, what constitutes a 'style', or whether the operation has any side effects. It is honest but minimal, adding limited context beyond the tool name.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence: 'Get all styles from the current Figma document'. Every word earns its place, with no redundancy or filler. It is appropriately sized for the tool's simplicity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the zero-parameter schema and lack of annotations or output schema, the description is reasonably complete for a simple getter. However, it does not describe the return format (e.g., an array of style objects) or clarify what categories of styles (fill, text, etc.) are included, which an agent would need to know to process the result correctly. It is adequate but has clear gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, and the schema is empty with 100% coverage (vacuously). The description does not need to explain parameter semantics because there are none. Baseline for 0 parameters is 4, and nothing in the description detracts from that.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb 'Get' with a clear resource 'all styles' and scopes it to 'current Figma document'. This distinguishes it from sibling tools like get_local_components and get_annotations, making the tool's purpose immediately clear.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It does not mention that this is for styles only, nor does it point users to sibling tools for other resource types. No contextual cues about typical use cases or exclusions are given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations present, the description carries the full burden. It explicitly indicates a read operation ('Get') and the scope ('current selection'), but does not elaborate on what 'all node details' encompasses, potential failure modes (e.g., empty selection), or response size/limitations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence of 14 words, front-loaded with the action and scope, with no filler or redundancy. It is concise and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema and no parameters, the description should clarify what 'detailed information' includes. Saying 'all node details' is broad but vague; the agent cannot know the exact fields or structure. This is a moderate gap for a tool that likely returns a complex selection object.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters and an empty input schema. The description correctly avoids parameter details. Per the baseline rule for 0 params, a score of 4 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Get'), the resource ('detailed information about the current selection in Figma'), and the scope ('including all node details'). This distinguishes it from sibling tools like get_selection or get_node_info, which focus on selection IDs or specific node queries.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives such as get_selection or get_node_info. The description does not mention exclusions, preferred contexts, or trade-offs.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description carries the full burden of behavioral disclosure. It only states the action without mentioning side effects, prerequisites (e.g., frame must already be auto-layout), error handling, or in-place mutation. This is a significant gap for a mutation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5Is the description appropriately sized, front-loaded, and free of redundancy?
One sentence, 13 words, perfectly front-loaded with the action and target. Every word earns its place, with no wasted content.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description is adequate given the schema's thorough parameter documentation, but it omits important context like whether the frame must already be auto-layout, what happens if it isn't, and that there is no return value. No output schema or annotations increase the need for such context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with detailed descriptions for both enum parameters, including the SPACE_BETWEEN side effect. The description adds no additional parameter-specific semantics, so the baseline of 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Set') and the specific resources ('primary and counter axis alignment for an auto-layout frame'), making it straightforward to understand what the tool does. It is distinct from sibling tools like set_layout_mode or set_padding because it focuses specifically on alignment.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides a clear context by specifying it applies to 'an auto-layout frame', implying when the tool should be used. However, it does not explicitly mention alternatives or exclusions, so while the context is clear, there is no comparative guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden. It discloses that the tool operates on a 'selected component instance' or an explicitly provided nodeId, which is useful. However, it does not mention what happens if no instance is selected, whether overrides are returned recursively, or any side effects (though it's a read operation). The description is minimal but not misleading.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences packed with relevant information. There is no fluff; every word contributes to understanding what the tool does and why it matters. Excellent front-loading of the core purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple read-only tool with one optional parameter and no output schema, the description is sufficiently complete. It explains the purpose, the input behavior, and the downstream use case. A slightly richer description of return format or error conditions could earn a 5, but overall it is comprehensive enough.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, with the 'nodeId' parameter fully described in the schema. The description reaffirms the optionality and selection fallback but adds no new semantic details beyond the schema. Baseline 3 is appropriate as the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Get all override properties from a selected component instance.' This is a specific verb+resource combination that distinguishes it from sibling tools like 'set_instance_overrides' (which writes overrides). The additional sentence about applying overrides to other instances clarifies the broader context.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies a clear use case: reading overrides to apply them elsewhere. It does not explicitly exclude alternatives or state when not to use it, but it effectively contrasts with the sibling 'set_instance_overrides' by focusing on 'get.' The phrase 'These overrides can be applied to other instances' hints at a typical workflow, providing some usage guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses the critical behavioral requirement that the output must be post-processed, which adds useful beyond-schema context. However, it does not describe the output format, potential errors, or other behaviors, so it's only moderately transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences: the first states purpose, the second delivers a critical instruction. No filler words, front-loaded and easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple (one parameter, no output schema), and the description covers the essential workflow step (post-processing to generate connectors). It does not explain the return value structure, but the critical instruction provides enough context for an agent to proceed. This is slightly above average given the tool's simplicity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% for the single parameter 'nodeIds', and the description already provides a brief meaning ('Array of node IDs'). The description adds no further detail about how nodeIds affect the result, so it meets the baseline but does not exceed it.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Get') and resource ('Figma Prototyping Reactions') with a specific scope ('from multiple nodes'). This distinguishes it from sibling tools like get_node_info or get_annotations, which target different types of data.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context on how to use the tool: its output must be processed using the 'reaction_to_connector_strategy' prompt and fed into 'create_connections'. It doesn't explicitly compare with alternatives, but it establishes a concrete workflow, which is strong usage guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It clearly states the mutation: target instances are swapped to the source component and all copied override properties are applied. It does not mention reversibility or whether existing overrides are overwritten, but the core behavioral consequence is transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, with the primary action in the first sentence and the result in the second. It is front-loaded, contains no filler, and every word contributes to understanding the tool's function.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a two-parameter tool with no output schema, the description explains the operation well. It implies the prerequisite of copying overrides and using a selection. It could be more explicit about what 'overrides' are and the need for a selection, but this is adequately covered by the schema parameter descriptions, making the description complete enough for an agent to use correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema provides 100% coverage with descriptions for both parameters (sourceInstanceId and targetNodeIds). The description text adds minimal extra semantic value beyond the schema, merely restating the roles of the source and target via context ('previously copied', 'selected'). This aligns with the baseline 3 for full schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Apply previously copied overrides to selected component instances') and its effect ('Target instances will be swapped to the source component and all copied override properties will be applied'). It uses a specific verb and resource, and distinguishes from sibling tools like get_instance_overrides (retrieves overrides) and create_component_instance (creates new instances).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use the tool: it requires previously copied overrides and a current selection of component instances. It implicitly signals the workflow (copy first, then apply). However, it does not mention alternatives or explicitly state when not to use it, which prevents a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
GitHub Badge
Glama performs regular codebase and documentation scans to:
- Confirm that the MCP server is working as expected.
- Confirm that there are no obvious security issues.
- Evaluate tool definition quality.
Our badge communicates server capabilities, safety, and installation instructions.
Card Badge
Copy to your README.md:
Score Badge
Copy to your README.md:
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/ysocrius/Talk-to-Figma-Cursor'
If you have feedback or need assistance with the MCP directory API, please join our Discord server