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 explaining behavior. It states that conversion happens, but does not disclose whether this is one-way, whether it modifies Figma files, whether mapping to Design System components is required, or what the generated output contains beyond 'Vue component code'.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single clear sentence with no filler. The main action, input, output, and design-system constraint are all front-loaded and every word earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool has no annotations, no output schema, nested parameters, and several similar sibling tools, so the description needs to carry more weight. It does not explain the return format, generation behavior, prerequisites, or how this differs from related code-generation tools, leaving an agent with meaningful uncertainty.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The description reinforces the primary input (Figma frame) and adds the design-system context, but it adds little detail about the options object. The schema already describes scriptLang, componentName, includeScript, and includeComments; with only 50% schema description coverage, the description offers only marginal compensation for the less-documented option parameter.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description names a specific verb ('Convert'), a concrete input ('Figma frame/screen'), a concrete output ('Vue component code'), and a distinguishing constraint ('using Design System components'). This clearly differentiates it from siblings like generic generate-code or map-figma-component.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description gives no guidance on when to choose this tool over alternatives such as generate-code, generate-figma-component, or map-figma-component. It does not state exclusions, prerequisites, or context for appropriate use.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

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 does not state whether the generated code is returned only, whether it has side effects, whether the component must already exist, or what the output format looks like. 'Generate' implies code creation but leaves important behavior unspecified.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single efficient sentence with no filler or repetition. It front-loads the primary purpose and keeps the core information immediately visible, though it is arguably too terse to fully support the tool's complexity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

There is no output schema and no annotation metadata, so the description must carry more context. It does not state what the tool returns (e.g., code string, file, snippet), how the optional includeScript affects output, or how this tool fits with related component tools. Given three parameters and a nested object, this is incomplete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does 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 adequately. The description adds only the phrase 'with the specified props', which confirms the props parameter's purpose but does not meaningfully exceed the schema's own explanations.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific action ('Generate'), a clear resource ('Vue component code'), and a key input ('specified props'). It is not a tautology and conveys the core function. However, it does not explicitly distinguish itself from the similar sibling 'generate-figma-component', so the differentiation is left to inference.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is given about when to use this tool versus alternatives such as get-component, get-examples, or generate-figma-component. The description only states what it does, leaving the agent to infer when it is the appropriate choice in a workflow.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

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 only states that Vue code is generated; it does not mention side effects, output format, dependencies, or whether a Figma mapping is required beforehand.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence with no filler and the action verb is front-loaded. It is concise and readable, though slightly under-specified; every word earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With no output schema and no annotations, the description leaves return format, behavior, and invocation context unclear. For a tool with three parameters and thirteen siblings, this one-liner is not sufficient for reliable selection and correct use.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema has 100% description coverage for all three parameters, so the baseline is 3. The description adds little beyond the schema; 'with specific properties' loosely corresponds to the properties parameter but does not clarify how figmaComponentName, properties, and instanceName interrelate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb ('Generate') and a clear resource ('Vue code for a single Figma component'), so the core action is understandable. However, it does not distinguish itself from siblings like generate-code or convert-figma-to-vue, leaving potential ambiguity about which tool to choose.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no guidance about when to use this tool versus nearby alternatives such as generate-code, get-component, or convert-figma-to-vue. The description gives no use-case context, no exclusions, and no selection criteria.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description takes on the full burden of explaining behavior. It clearly discloses the output format (Markdown), the content sections (props, events, examples, mistakes, related components), and the notable behavioral trait of 77% token savings versus JSON. This goes beyond a generic 'get' description and informs the agent of efficiency implications. It does not disclose potential response size or pagination, but the content list and token-savings hint provide strong transparency.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is well-structured and front-loaded: the core purpose is in the first sentence, followed by a concise bullet-style list of content, and a final note about token efficiency. Every sentence adds value; no filler or repetition.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a single-parameter read tool with no output schema, the description is quite complete. It outlines exactly what the response will contain and even addresses the format/token trade-off. Minor omissions include not mentioning error conditions (e.g., unknown component name) or whether output includes 'when to use' guidance, but these are not significant given the tool's simplicity.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The single parameter 'name' already has a description in the schema with examples (e.g., InButton, InDatePickerV2), so schema coverage is 100%. The tool description adds no extra parameter-level detail beyond what the schema provides, warranting the baseline score of 3.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb, resource, and format: 'Get detailed information about a specific Design System component in Markdown format.' Distinguishes itself from sibling tools like list-components, get-props, get-events, get-examples by emphasizing its comprehensive nature and Markdown output, which is a clear differentiator.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage: call this tool when you need complete component documentation in a single, token-efficient Markdown response. It does not explicitly state when to prefer this over get-props, get-events, or get-examples, nor does it describe when one of those narrower tools would be more appropriate. The token savings note provides some decision context but falls short of explicit routing guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

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 only says 'Get ... information,' which implies a read operation, but it does not describe the return shape, error behavior, or what happens when the component is not found or mapped to a design system.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, front-loaded sentence with no redundant words. It is appropriately terse for a one-parameter lookup, though the brevity limits how much context it can provide.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With no output schema and no annotations, the description should clarify what 'Design System component information' includes and how this tool relates to the sibling tools. It does neither, so an agent can invoke it but cannot reliably predict the result or choose it confidently among 13 alternatives.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, and the single parameter, figmaComponentName, is already documented as 'Figma component name.' The description adds no additional meaning, examples, constraints, or formatting guidance beyond what the schema provides, 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.

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb 'Get' and a clear resource, 'Design System component information,' with the input being 'a Figma component name.' The 'Design System' qualifier helps distinguish it from the generic sibling get-component, though 'information' remains somewhat vague.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no guidance about when to use this tool versus the many siblings such as list-components, get-component, search-components, get-props, or get-examples. The description restates the operation but offers no alternatives, exclusions, or selection criteria.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the burden of behavioral disclosure. It conveys that this is a read-style operation returning all events with payloads, but it does not mention pagination, ordering, error behavior, or whether any side effects occur.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, tight sentence that front-loads the action, resource, and scope. Every word contributes meaning, with no filler or redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a tool with one parameter and no output schema, the description is minimally adequate: it states what the tool returns. However, it lacks detail about the output structure, potential empty results, or any constraints beyond the component name, so an agent is left with some ambiguity.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100% and the single parameter 'name' is already documented as 'Component name'. The tool description adds no additional parameter details, so it stays 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.

Does 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 events emitted by a component') and adds meaningful scope ('all') and content ('with their payloads'). It is clearly distinct from sibling tools like get-props or get-examples.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does 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 get-props, get-component, or search-components. There is no mention of conditions, exclusions, or when a sibling tool would be more appropriate.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

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 only says the tool gets code examples; it does not disclose output format, behavior on unknown component names, or whether examples are fetched or generated. The word 'Get' weakly implies a read-only operation but nothing more.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, front-loaded sentence with no wasted words. For a tool with one parameter, this is appropriately concise, though it sacrifices useful detail.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the low complexity of one parameter, the description is minimally adequate: an agent knows the tool returns code examples for a named component. However, with no output schema and no annotations, a bit more detail about the return format or example selection would make it fully complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, with the single 'name' parameter already described as 'Component name'. The tool description adds no meaningful parameter semantics beyond that, so the baseline of 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb ('Get') and a clear resource ('code examples for using a component'). It is distinct enough from sibling tools like get-component or get-props, though it does not explicitly contrast itself with generate-code.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no guidance about when to use this tool versus alternatives such as get-component, get-props, or generate-code. No exclusions, preconditions, or selection criteria are provided, leaving the agent to infer appropriateness 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.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description itself indicates this is a read-only retrieval operation and states the content of the returned props information. However, it does not disclose error behavior, whether component names are exact matches, or any other edge-case handling.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single focused sentence with no filler. It front-loads the action and resource, then adds useful output details about types, defaults, and descriptions.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple one-parameter getter with no output schema, the description adequately states the purpose and the returned information. It is slightly incomplete in not covering potential errors or exact-match requirements, but the low complexity keeps the gap minor.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the single 'name' parameter is already documented as 'Component name'. The description adds no further parameter-level detail beyond the schema, meriting the baseline score.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses the specific verb 'Get' with the resource 'detailed props information' and enumerates the contained fields (types, defaults, descriptions). This clearly distinguishes it from sibling tools like get-component, get-events, and get-examples.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No usage guidance is provided. The description does not state when to prefer this tool over get-component or search-components, nor does it mention any exclusions or alternative conditions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full behavioral disclosure burden. It states the operation but reveals nothing about return format, the size of an unfiltered 'all' listing, pagination, or how invalid category values are handled. For an unbounded enumeration, this is a meaningful gap.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

One sentence, eleven words, with the verb and scope front-loaded. Every word earns its place and there is zero filler.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With no output schema and no annotations, the description should cover return-value expectations, but it says nothing about what a listing entry looks like or how results are bounded. For a simple one-optional-parameter tool it is adequate for invocation, yet it still leaves an agent guessing about response shape and scale.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%: the category parameter already has a clear description with examples. The tool description adds nothing beyond echoing 'optionally filtered by category', so it neither helps nor hurts — the baseline of 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb with a clear resource and scope: 'List all available Design System components', with an optional category filter. The name and phrasing distinguish it from siblings like get-component and search-components, but it never explicitly names those alternatives, so differentiation is inferred rather than stated.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Usage is implied but not stated: 'List all available...' suggests a catalog-browsing purpose versus search-components for query-based discovery or get-component for a single item. There is no explicit when-to-use/when-not-to-use guidance, and the optional category filter is the only hint at scoping a call.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

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 disclosing behavior. It states that the tool lists mappings, which implies a read-only operation, but it does not mention side effects, output format, ordering, or any other behavioral detail.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, compact sentence that directly states the tool's purpose without redundancy or filler. It earns its place fully.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple, zero-parameter listing tool, the description is largely complete. It identifies exactly what is listed, though it does not describe the output format since no output schema is present; this is a minor gap given the low complexity.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has zero parameters and the schema is vacuous, so there is no parameter meaning to clarify. The baseline of 4 applies because no parameter documentation is needed beyond what the empty schema already conveys.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb and resource: it lists mappings between Figma components and Design System components. It is clearly distinguishable from siblings such as list-components and search-components because it names a distinct artifact type, the mapping.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies the tool is appropriate when an agent needs an overview of existing Figma-to-Design-System mappings. However, it does not explicitly contrast it with list-components or map-figma-component, nor does it state 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.

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 states the mapping outcome and that default props are included, but it does not disclose behavior for unmapped names, whether the operation is read-only, or what the exact return shape is. This is a meaningful gap for a tool with no safety hints.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single sentence that is direct, front-loaded, and free of filler. It conveys the core action and expected result without unnecessary detail.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

This is a low-complexity tool with one simple parameter and high schema coverage, so less description is needed. However, with no output schema and no behavior around missing mappings or return structure, the description is adequate but not fully complete for an agent to predict all outcomes.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, and the single parameter is well documented with examples. The description adds minimal parameter-level meaning beyond the schema, but the baseline remains acceptable because the schema already carries the semantic weight.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb ('Map') with a clear resource (Figma component name) and outcome (corresponding Design System component with default props). It distinguishes itself from sibling tools like list-figma-mappings by focusing on a single mapping rather than a listing.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies use when a Figma component name needs to be resolved to a Design System component, but it provides no explicit guidance on when to choose this over siblings like get-component, get-props, or list-figma-mappings. No exclusions or alternative conditions are mentioned.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the behavioral burden. It discloses the transformation process, mentions token awareness, and states the output includes tool sequence and savings estimates. However, it does not explicitly state whether the operation is non-mutating, whether it has side effects, or any limitations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is well-structured: a clear one-sentence definition, a brief process explanation, and a concrete example. It is appropriately sized and front-loaded, though the phrase 'for better Design System integration' adds little functional value.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Even without an output schema, the description tells the agent what the tool returns: an optimized prompt with tool sequence, token savings estimates, and clear steps. It positions the tool clearly relative to the sibling set, but lacks explicit guidance on language handling or edge cases.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema already documents the userPrompt parameter with 100% coverage, so the baseline is 3. The description adds an example and explains that the parameter should be a raw user prompt, but it does not add significant new meaning beyond what the schema states.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb and resource: 'Transform raw user prompt into MCP-optimized prompt'. It also clarifies the tool's role as an orchestrator that guides Claude to use the right MCP tools, which visibly distinguishes it from the sibling component/documentation tools like list-components or generate-code.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Usage context is implied: this is for taking a raw user prompt and converting it into a structured, tool-sequenced prompt. The example illustrates a concrete input, but there is no explicit statement about when to choose this tool over alternatives 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.

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 does clarify that search matches against name, description, or category, which is useful context. However, it does not disclose whether the tool returns a list, how partial matching works, whether results are paginated, or what happens on an empty result set.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence that states the action, resource, and search dimensions with zero filler. Every word earns its place, and the most important information is front-loaded.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple one-parameter search tool with no annotations and no output schema, this description is mostly sufficient: the agent knows what to pass and what kind of operation to expect. The main gaps are a lack of explicit result-shape information and no guidance about when to use list-components instead, but the low complexity keeps these gaps minor.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema only describes the 'query' parameter as 'Search query', which is extremely vague. The description adds meaningful semantics by stating that the query applies to component name, description, or category. This goes beyond the schema's coverage and gives the agent a clear idea of what values are appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb ('Search') and resource ('Design System components') and names the exact search dimensions: name, description, or category. This makes it clearly distinguishable from siblings like list-components and get-component, so an agent can tell what this tool does without opening its schema.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The verb 'search' implies this should be used when an agent needs to find components by free-text query rather than listing all components or fetching a specific one. However, the description never explicitly states when to prefer this over list-components or get-component, nor does it mention exclusions. Usage guidance is implied, not stated.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the behavioral burden. 'Check if' strongly implies a non-mutating read-only predicate, but it does not disclose the return format, error behavior, or whether the check is based on static naming rules or live mapping data. These gaps prevent a higher score.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single clear sentence with no filler or repetition. The core action and target are front-loaded, making it very easy for an agent to parse quickly.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple one-parameter validation tool, the description covers the basic purpose and input adequately. However, with no output schema and no usage guidance, it leaves the agent to infer the return value and ideal invocation context, so it is not fully complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The single parameter figmaComponentName is 100% covered by the schema's description and example. The tool description adds no extra meaning beyond the schema, so the baseline of 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb ('Check if') with a clear resource ('Figma component name') and outcome ('can be mapped to a Design System component'). It clearly distinguishes this validation tool from sibling tools like map-figma-component, which would actually perform the mapping.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The phrase 'Check if ... can be mapped' implies a pre-validation or verification use case, especially alongside map-figma-component. However, it does not explicitly state when to prefer this tool over alternatives, nor does it mention any prerequisites or workflow context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.