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. It states that the tool returns a 'structured diff', which implies a read-only operation, but it does not clarify whether it performs network requests, has rate limits, or requires authentication. It also doesn't specify the format of the diff (e.g., object vs. array) or error conditions (e.g., invalid URLs). This lack of detail could lead an agent to misuse the tool or misjudge 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.

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

The description is a single, compact sentence that front-loads the core purpose and output type. It uses efficient wording with no redundant phrases, making it easy to scan quickly. Every word contributes to understanding the tool's function, and the structure is ideal for an AI agent's token budget.

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 that there is no output schema and no annotations, the description must provide sufficient context for an agent to call the tool correctly. It does not explain the exact input requirements (e.g., both URLs optional but one required), the meaning of the diff (e.g., including prop changes), or edge cases like mismatched deployments. The description is too sparse for a tool with 3 parameters and significant complexity from comparing deployments.

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 covers 0% of parameters via descriptions, so the tool description must compensate, but it only mentions 'two Storybook deployments' and 'baseUrl' is not explained. The description doesn't explain that baseUrl is the baseline deployment and targetUrl is the one to compare against, or that components allows filtering to specific components. The agent cannot infer parameter semantics without opening the schema and making reasonable assumptions, which is risky for a comparison tool.

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 explicitly states the action 'Compare' and the resource 'two Storybook deployments', and specifies the exact output: 'structured diff (added/removed/modified components, prop changes)'. This clearly differentiates from sibling tools like preview_story or get_component, which focus on viewing or fetching individual items rather than comparing versions. The verb-resource pairing is specific and unambiguous.

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 does not provide any guidance on when to use this tool versus alternatives like find_stories_by_source_file or get_component_dependencies. It lacks context about typical use cases (e.g., when checking for breaking changes) and does not mention exclusions (e.g., not for comparing token sets, which get_design_tokens might handle). The user must infer usage from the name and description alone, which is insufficient for a tool with many siblings.

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. It communicates that this is a read-only discovery operation ('find matching stories'), but it does not disclose match semantics, result format, behavior when no story matches, or path requirements beyond being a component source file path.

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 that states the operation type first ('Reverse lookup'), then the input, then the result. Every word earns its place with no 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 simple required parameter and no output schema, the description is reasonably complete: it explains the input and the intended result. It could add detail about output shape or matching behavior, but the low complexity reduces the risk of an agent calling it incorrectly.

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 0%, so the description must compensate. It does so by clarifying that sourceFile is a component source file path, adding meaning beyond the bare parameter name. The parameter is simple and required, so the ambiguity is limited.

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 ('find') and resource ('Storybook stories'), and clearly frames the operation as a reverse lookup from a source file path. This distinguishes it from siblings like list_stories or search_stories without needing to open their schemas.

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 'Reverse lookup' implies this tool is specifically for finding stories by source file, which differentiates it from broader search/list siblings. However, there is no explicit guidance on when to prefer 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?

With no annotations, the description carries the full burden. It usefully discloses that near matches are advisory rather than actionable, and that exact matches yield concrete replacements, but it never states that this is a read-only static analysis, whether any limits or truncation apply to large inputs, or how the output is structured beyond the replacement hint.

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?

Two tight sentences with the core purpose front-loaded and the caveat about near matches placed second. No filler, though the parenthetical could be folded in more economically.

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?

No output schema and no annotations mean the description is the only context. It hints at the return shape (var(--token) replacements) and clarifies tolerance semantics, but omits the meaning of remBase, how filename affects results, and any input-size caveats, leaving gaps for a 5-parameter tool.

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 0% with 5 parameters, so the description must compensate. It partially does: the category names (colors, spacing, radius, font sizes) map onto the categories enum and it explains the tolerance parameter's effect, but remBase, filename, and code are left entirely undocumented.

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 (find) and resource (hardcoded colors, spacing, radius, font sizes in CSS/JSX) plus what it produces (var(--token) replacements). The purpose is unambiguous and distinguishable from get_design_tokens or validate_usage, though no sibling is named to sharpen the contrast.

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 second sentence gives interpretation guidance ('near matches with tolerance > 0 are hints only'), but that is about reading results, not about when to choose this tool over validate_usage or get_design_tokens. Usage is only implied from the purpose, with no explicit when/when-not or alternatives.

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 full burden. It usefully discloses that the operation affects 'local' memory rather than a remote/shared store, but it omits whether removal is idempotent, what happens if the component is not in the pending list, and whether the change is reversible.

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 front-loaded sentence that states the action and its scope with no filler. It is efficient, though almost too terse for a tool with no annotations backing it up.

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 mutation this is roughly adequate, but with no annotations, no output schema, and 0% schema coverage, the description leaves edge-case and effect behavior undocumented.

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 0% for the single componentName parameter, so the schema supplies only type and length bounds. The description implies the argument identifies a component within pending memory but adds no syntax or format detail (e.g., name vs. identifier) beyond that inference.

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 gives a specific verb-plus-resource ('Remove a component') and scopes it to 'local pending-component memory,' which separates it from unrelated siblings like get_component or list_components. It does not explicitly name its inverse sibling remember_component, so sibling differentiation is implied 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?

There is no statement of when to call this versus alternatives, nor any prerequisite or exclusion. The agent must infer from the name that this is the inverse of remember_component and only applies to items still pending.

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 disclosure burden. It adds genuinely useful domain context — the source=pending marker means a component exists in code but is absent from Storybook — which is real behavioral information. However, it never states permissions, read-only nature (implied only by the 'get' prefix), or result size/limits for a tool that enumerates 'every' component.

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?

Three tight sentences with the timing imperative ('Call BEFORE writing any UI code') front-loaded, followed by payload contents and one edge-case note. No 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?

For a zero-param-required read tool with no output schema and no annotations, the description covers what to expect back and when to call it, which is solid. The two filter parameters remain entirely unexplained, which is the meaningful remaining gap.

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 0% and the description never mentions either parameter. It is unclear whether 'category' filters the catalog or what 'maxDescriptionLength' truncates; the phrase 'short description' only hints at the latter. With two undocumented params the description should compensate and does not.

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?

Specific verb+resource ('get_catalog_summary' → 'compact catalog of every design-system component') with the exact fields returned (name, import, short description, key props) spelled out. This lets an agent distinguish it from siblings like list_components, get_component, and get_component_usage without opening any 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?

Explicit trigger: 'Call BEFORE writing any UI code', plus the goal ('reuse existing components instead of building new ones'). It does not name a competing sibling or state when NOT to use it, so it stops short of a 5.

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 only states 'Get' (implying a read) and mentions the included content, but does not address potential failure modes, error behavior, authentication requirements, rate limits, or any side effects. This is a significant gap for a tool that has no annotation fallback.

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 exactly two short sentences with no filler. The primary action and key example are front-loaded, and the additional output note is brief. Every word earns its place, making it appropriately concise for the information it conveys.

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 three parameters, no output schema, and no annotations, the description leaves critical gaps. It does not explain what 'docs overview' or 'story variant ids' mean, the effect of the optional parameters, or the default behavior. An agent would likely need to probe the tool or refer to other documentation to call it confidently.

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 0%, so the description must compensate. It clarifies the 'component' parameter via the name/path wording and examples, but provides no explanation for 'maxContentLength' or 'includeOverviewContent'. These two optional parameters are left completely unexplained, leaving the agent unsure about their effect and defaults.

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 clearly states a specific verb ('Get'), a resource ('component'), and the lookup method ('by name or path') with concrete examples ('Alert, Components/Alert'). It also indicates return content ('docs overview and story variant ids'), distinguishing this from sibling tools like list_components or get_component_config.

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 when you need a single component's details by name or path, but it does not explicitly mention alternatives or conditions. There is no reference to list_components for listing all components or get_component_config for configuration-only needs, leaving the agent to infer when this tool is the right choice.

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 must carry behavioral disclosure. It discloses the data returned (argTypes and stylePresets), which is useful, but does not mention whether the operation is read-only, any side effects, or error behavior. 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.

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

A single, front-loaded sentence that immediately communicates the core purpose and key return fields. No filler words or redundant phrasing.

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 description gives a high-level overview of the output but lacks details on output structure (e.g., exact shape of argTypes or stylePresets), parameter formatting, or potential error conditions. Given there is no output schema, the description should be more explicit to fully prepare an agent.

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 0% and the description does not explicitly define the 'component' parameter beyond implying it is the component identifier. The phrase 'per component' offers a hint, but there is no detail on format, allowed values, or how to reference a component. This leaves the parameter under-specified.

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 clearly states the tool retrieves Storybook Controls configuration for a component, specifying exactly what is returned (argTypes and stylePresets with args). It is specific and distinct from siblings like get_component (which likely returns component metadata) and get_story (which returns story content).

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 explicit when-to-use guidance or comparison to alternatives. The description implies it is for Controls configuration, but does not state when to prefer this over get_component or get_story. It is not misleading, but leaves selection to inference.

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 mentions the graph nature but does not state whether the operation is read-only, whether depth or direction parameters affect the result in a way that might have side effects, or whether there are any performance/limit considerations. Since no annotations exist, this gap is significant.

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 one concise sentence that front-loads the core purpose and includes a clarifying explanation of the two directions. Every word earns its place, and it is appropriately sized for a graph-returning tool.

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 that there is no output schema, the description should hint at the return format (e.g., a graph structure) to help the agent interpret the result. It doesn't. Additionally, with 0% schema coverage and no annotations, the description fails to explain how the parameters interact. The description provides a high-level purpose but omits critical details for correct invocation and result interpretation.

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 0%, meaning the description must compensate for the lack of parameter documentation. The description explains the 'dependencies' and 'dependents' direction concept generally, but it does not explicitly map to the 'direction' parameter or clarify how 'depth' affects the traversal. It adds some value beyond the schema but is insufficient given the low 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 states a specific verb ('Get') and resource ('component dependency graph'), and further clarifies the semantics by explaining both directions: which components a component uses, and which components use it. This is clear and distinct from siblings like get_component_usage, though it doesn't explicitly name the sibling it differs from.

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 when to use this tool (when needing dependency information) but provides no explicit guidance on when not to use it or which sibling to choose instead. The sibling list includes get_component_usage, which likely overlaps, but the description doesn't differentiate. This leaves the agent to infer the usage context.

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 safety disclosure burden; 'Get' implies a non-mutating read and the phrase 'built from story argTypes and preset args' reveals the source data. However, it does not mention failure modes (e.g., missing story/component, unknown variant) or whether the code is fetched live versus generated statically. The transparency is adequate for a simple getter but has clear gaps.

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 front-loads the key output ('copy-paste-ready component usage code') and packs import/JSX and the data source into a parenthetical and a trailing phrase. Every word earns its place, with no redundant repetition of the tool name.

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 no output schema and no annotations, the description explains what is returned (import + JSX code) but not how the optional parameters shape that return value. An agent could call with only componentName, but would be guessing about format and variant semantics. The core behavior is captured, yet the missing parameter guidance leaves the description 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 0%, so the description had to explain format, variant, and componentName, but it only alludes to component-level input. 'tsx' vs 'jsx' and the meaning of 'variant' are left entirely to the schema, and no mapping between 'preset args' and the variant parameter is given. The clue about 'story argTypes and preset args' is the only extra semantic it contributes.

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 ('Get') and a concrete, distinctive resource ('copy-paste-ready component usage code (import + JSX)'), and explains the source ('story argTypes and preset args'). This makes it clear the tool emits a code snippet rather than metadata or story content, which separates it from siblings like get_component or get_story. It stops short of explicitly naming alternative tools, so it gets a 4 rather than a 5.

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 right use case: when an agent needs a ready-to-paste usage snippet for a component. It does not state when not to use it or point to an alternative tool, so an agent must infer selection from the sibling names. That is adequate but not explicit.

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. 'Extract' implies a read-only operation)Skip, but the description does not state what is returned, whether tokens are grouped, how the optional category parameter affects output, or what happens when no category is supplied. For a tool with no output schema, this leaves meaningful behavioral gaps.

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. The core verb and resource are front-loaded, and the parenthetical examples add useful detail without bloating the definition.

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 only one optional parameter and no required inputs, the description is minimally workable: an agent can infer that calling it extracts tokens. However, with no output schema and no annotations, it should at least clarify the default category behavior or the shape of the extraction result. The gaps are not fatal but prevent full autonomy.

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 for the single parameter is 0%, and the description only repeats token categories already visible in the enum. It does not explain the role of the optional category parameter, its default behavior, or what 'other' and 'all' mean semantically. The enum values are self-describing, but the description adds little beyond the schema.

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 ('Extract') and clearly identifies the resource ('design tokens' sourced 'from Storybook CSS variables'), with concrete examples of token types. It is readily distinguishable from all sibling tools, which focus on components, stories, and versions rather than token extraction.

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 makes the use case obvious: call this tool when design tokens need to be pulled from Storybook CSS variables. It does not explicitly name alternatives or exclusion criteria, but the sibling list contains no competing token-extraction tool, so the implied usage is clear and sufficiently contextual.

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 present, so the description must carry the behavioral disclosure burden. It only says 'Get', implying read-only, and mentions an optional cap, but does not state side effects, return payload, truncation behavior, or any auth/rate constraints.

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 with no filler, and the core action and key option are front-loaded. Every word contributes.

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?

Despite low complexity (2 params), the lack of annotations and output schema means the description should clarify return shape, cap behavior, and when to choose this vs siblings. It covers neither, leaving an agent to guess.

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 0%, so the description must add meaning. It explains maxContentLength as a 'content length cap' but leaves units and truncation behavior unspecified; storyId is only inferable from the property name and the noun 'story'.

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 specifies the verb 'Get' and the resource 'a full story', clearly signaling a single complete retrieval. This distinguishes it from siblings like get_story_section, get_story_metadata, list_stories, and search_stories.

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 'full story' implies use when complete story content is needed rather than a section or metadata, but the description never explicitly states when to prefer this tool over siblings or mentions alternatives. No exclusions or conditions are provided.

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?

Since no annotations are provided, the description carries the full behavioral burden. 'Retrieve... context' implies a read operation, but the description does not disclose what shape the returned context takes, whether storyId scopes the retrieval, or how maxResults affects results.

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, front-loading the action and resource. Every word contributes to the core meaning, making it efficient and easy to parse.

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 no annotations, no output schema, and 0% parameter description coverage, the description is too thin to support reliable invocation. An agent cannot infer what 'context' consists of, what storyId and maxResults do, or what the response will look like.

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 0%, so the description needed to explain the query, storyId, and maxResults parameters. It only clarifies that query is a natural-language question; the semantics of the optional storyId and maxResults parameters are left entirely to the schema's bare names and constraints.

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 ('Retrieve') and object ('concise Story Book context') tied to a natural-language question, which gives a clear sense of what the tool does. It is not fully distinguished from siblings like search_stories or get_story_section, but the focus on 'context for a natural-language question' differentiates it from simple story or metadata retrieval.

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 'for a natural-language question' implies when the tool would be useful, but there is no explicit guidance about when to prefer it over alternatives like search_stories or get_story. No exclusions or sibling comparisons are provided.

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. The verb 'Get' indicates a read-only retrieval and the object 'instructions' suggests the output is guidance text, so there is no contradiction or hidden mutation. However, it does not disclose the output format, whether the instructions are static or generated, or any other behavioral details.

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 compact sentence with the core action and a parenthetical scope list; 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 zero-parameter, no-output-schema tool, the description is mostly complete: it states what the agent gets, the topic, and the covered areas. The only notable omission is explicit guidance on when this is the right tool versus a story-data sibling, which is already reflected in usage_guidelines.

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?

There are no parameters, so the schema is complete at 100% and the tool cannot be misconfigured. The description adds useful domain context about what the instructions cover, which is all that is needed.

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 action ('Get best-practice instructions' for writing stories), a clear resource (Storybook stories), and the scope (CSF3, argTypes, play functions). This distinguishes it from sibling tools that retrieve story content or metadata, like get_story or get_story_metadata, by pointing at guidance rather than data.

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 authoring guidance for Storybook stories, but it never states explicit when-to-use or when-not-to-use conditions or names alternatives. Sibling tools exist for retrieving story data, but the description does not tell the agent to prefer this one over those in specific situations.

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 does convey a useful behavioral trait—this operation avoids loading full story content—but it doesn't mention whether it is a safe read, any error behavior, authorization requirements, or the shape of the returned metadata.

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 one short sentence with no filler. The key scoping phrase 'without loading full content' earns its place by differentiating from get_story and reinforces the metadata-only intent.

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 read tool, the description is mostly usable, but with no output schema and no annotation coverage, it should clarify what metadata is returned or how it relates to other story retrieval tools. It is adequate but leaves meaningful gaps around return values and usage boundaries.

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 0%, and the description does not mention 'storyId' or add any meaning beyond the parameter name. The parameter is self-explanatory to some degree, but the description fails to compensate for the lack of schema-level guidance.

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 clear verb-resource pair ('Get story metadata') and adds the scope 'without loading full content', which distinguishes it from the sibling get_story. It is not a tautology and names the key intended outcome, though it doesn't explicitly enumerate what qualifies as 'metadata'.

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 'without loading full content' implies this tool is for metadata-only lookups, which gives some context for when to use it. However, it never explicitly names the alternative nor states when not to use it (e.g., when full story content or sections are needed).

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 only says 'Get one section' and does not mention whether the section content is returned in full, whether it includes nested components, what happens if the section does not exist, or any side effects. For a read operation this is a moderate gap, but the lack of any behavioral detail beyond the basic action 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.

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

The description is a single short sentence with no wasted words. It is front-loaded with the verb and resource. However, it is so terse that it sacrifices useful context, though conciseness itself is not the problem.

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 tool has no annotations, no output schema, and 0% schema description coverage, the description is too thin. An agent would not know what a section is, how it relates to a story, what the return value looks like, or when to prefer this over get_story_context or get_story. The sibling list suggests a rich domain, and this description does not orient the agent within it.

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 0%, so the description must compensate for the two parameters (storyId, sectionId). It does not explain what a 'section' is, how storyId and sectionId relate, or any format expectations. The parameter names are self-explanatory to a degree, but the description adds no meaning beyond the schema.

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 and resource ('Get one section from a story'), which is clear enough to identify the basic operation. However, it does not distinguish this from siblings like get_story, get_story_metadata, or get_story_context, so an agent cannot tell what makes a 'section' different from those resources.

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 on when to use this tool versus alternatives such as get_story or get_story_context. The description implies a narrow use case (fetching a single section) but provides no context about prerequisites, relationships to other tools, or when a different 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?

With no annotations, the description carries the transparency burden retreating at least says results are 'grouped' and 'Metadata only,' which are useful behavioral clues. However, it does not disclose pagination behavior, ordering, response shape, or error scenarios, so transparency is only partial.

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 includes the action, resource, grouping example, and a useful metadata-only caveat. There is no fluff, and the most distinguishing information appears first.

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 tool has four optional parameters, no output schema, and no annotations, but the description provides only a high-level statement. Missing details include what metadata fields are returned, how filters combine, how pagination behaves, and what categories are valid, making the definition insufficient for reliable invocation.

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 0% description coverage, and the description only provides a naming example rather than explaining the parameters. It does not clarify what `query`, `category`, `limit`, or `offset` control, leaving the agent to guess at filtering and pagination semantics.

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 action ('List'), a precise resource ('UI components from Storybook'), and a grouping format with concrete examples ('Components/Button, Components/Alert'). It also narrows scope to 'Metadata only,' which distinguishes this from content-returning sibling tools.

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 prefer list_components over list_stories, search_stories, or get_component. The agent must infer usage from the resource name alone, with no exclusions, prerequisites, or alternative routing 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?

With no annotations provided, the description carries the full behavioral burden, and it does disclose non-obvious lifecycle behavior: entries that appear in Storybook are 'dropped automatically' and old entries are 'flagged stale'. That is real signal beyond the name. It still omits read-only framing and any auth/volume context, which keeps it short of a 5.

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?

Two tight sentences, zero filler, with the primary scope stated first and the automatic maintenance behavior second. Every clause 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?

For a zero-parameter, no-output-schema listing tool, the description supplies the essentials: what is listed and what happens to entries over time. It hints at the return shape (a stale flag) but says nothing about ordering or size of the list, a minor gap 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 tool takes zero parameters, so there is nothing for the description to disambiguate and the baseline is 4. The absence of parameters is consistent with the description, which describes a plain listing with no filtering knobs.

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 (List) and a precisely scoped resource (locally remembered components not yet in the deployed Storybook). The 'locally remembered / not yet deployed' qualifier distinguishes it cleanly from siblings like list_components and list_stories without needing their schemas.

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 by the purpose — you call it when you want to see pending/local-only components — but the description never names an alternative or a when-not condition (e.g., use list_components for the full deployed catalog). Adequate but leaves routing to inference.

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 is the sole source of behavioral disclosure. It usefully reveals that the tool returns metadata only and not full content, but it does not explicitly confirm read-only behavior, pagination, or side effects. For a list operation this is acceptable, but there is room for more explicit safety language.

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 core action is front-loaded. It is appropriately compact, though its brevity comes at the cost of missing parameter and usage context. Still, every word contributes to the meaning.

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 one-sentence description is inadequate given five undocumented parameters, no output schema, and no annotations. The agent lacks information about filtering behavior, pagination, return structure, and how this tool relates to search_stories. A more complete description would explain at least the key parameters and the intended use case.

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 0%, and the description mentions none of the five parameters (tags, limit, query, offset, category). The agent has no way to know what these parameters do, how they interact, or whether any are required. The description fails to compensate for the schema's total lack of documentation.

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 ('List'), a resource ('Story Book entries'), and a clear scope ('metadata only, no full content'). This distinguishes it from get_story, which presumably returns full content, but it does not explicitly differentiate from search_stories, so it stops short of a perfect score.

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 like search_stories or get_story. There is no mention of exclusions, conditions, or recommended use cases, leaving the agent to infer the intended 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 carries the burden of behavioral disclosure. It conveys that the operation is a mapping/transformation and that the result includes suggested props, but it does not explain matching behavior, ambiguity handling, failure cases, or whether any network/auth constraints apply.

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 with no filler; the action, source, target, and output type are front-loaded. Every phrase earns its place and the description is easy to parse at a glance.

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 3 optional parameters, no annotations, and no output schema, so the description needs to compensate. It leaves unresolved how to choose between parameters, what the exact return shape is, and how matching behaves with no or multiple results. This is a meaningful completeness gap for an agent deciding how to invoke the tool.

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 0%, so the description must compensate. It loosely maps 'name/node/URL' to the three parameters (figmaName, figmaNodeId, figmaUrl), which adds meaning beyond the schema. However, it does not clarify whether these are alternatives, whether one must be provided, or what happens if multiple are supplied.

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 'Map' with a clear source ('Figma component name/node/URL') and target ('corresponding Storybook component'), plus a distinctive result ('suggested props'). This clearly differentiates it from all listed siblings, none of which mention Figma or cross-tool 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 use case: when you have Figma identifiers and need a Storybook component. However, it does not explicitly state when to prefer this over siblings like get_component or search_stories, nor does it mention exclusions or the relationship between the three possible Figma inputs.

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 'builds' a URL, but does not disclose whether it validates story existence, whether it returns a relative or absolute URL, whether it requires a running Storybook server, or what the output format is. More detail is needed.

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 one sentence with no waste, and it front-loads the core purpose ('Build a Storybook iframe preview URL') before mentioning optional parameters. It is efficient and easy to parse.

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 tool has 4 parameters with nested objects, no output schema, and no annotations. The description does not explain how the returned URL is used, how to obtain a valid storyId (e.g., from list_stories or search_stories), or any limitations. For an agent to call it correctly, more context is needed.

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 0%, so the description must compensate for parameter understanding. It mentions 'optional args, globals, and viewport' but does not explain what these are in the Storybook context, how they affect the URL, or the format beyond the schema's structural definition. The description adds minimal value over the raw schema.

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 ('Build') on a specific resource ('Storybook iframe preview URL'), and uniquely identifies this tool among siblings, all of which are data-fetching or analysis tools. It distinguishes by being the only URL builder.

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: when you need a preview URL for a story. However, it does not explicitly state when to prefer this over other tools, nor does it mention any exclusions (e.g., 'use this instead of get_story for rendering'). The context is clear but no explicit guidance is given.

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 full burden; it usefully discloses that data is 'Stored in a local file only,' which tells the agent this is a local, non-synced write. It omits whether re-recording an existing component overwrites or errors, whether the action is idempotent, and any permission requirements.

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?

Two tight sentences, zero waste. The purpose is front-loaded and the storage caveat follows immediately, so both key facts land before any schema inspection.

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 5-parameter mutation with no annotations, no output schema, and 0% parameter coverage, the description explains the purpose but nothing about the required fields or the effect of storing a component locally. It is not sufficient on its own to call the tool correctly.

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?

Five parameters with 0% schema description coverage means the schema documents no parameter at all, and the description adds no meaning for componentName, import, description, sourcePath, or componentSource. The agent must infer each field's role and format entirely on its own.

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 (Record) and resource (a component) plus its precise scope: components that exist in code but are not yet deployed to Storybook. This clearly separates it from siblings like list_pending_components, forget_component, and get_component without needing to name them.

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 condition for use is explicit ('exists in code but is not yet in the deployed Storybook') and the benefit is stated ('so catalog and validation tools include it'). No when-not guidance or named alternatives (e.g., scaffold_story) are given, so it stops short of a 5.

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 full burden and does well on the two most important traits: the return is file content only ("write it yourself") and there is a side effect of registering the component locally. It stops short of disclaimers about overwrites, idempotency, 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.

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

Two tight sentences, front-loaded with the trigger condition and artifact, with the surprising "returns content only" caveat placed last for emphasis. No wasted words.

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 six-parameter, no-annotation, no-output-schema tool, the description adequately covers the call trigger and return behavior but leaves the parameter contract entirely undocumented. Adequate but with a clear gap.

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?

All six parameters have 0% schema description coverage and the description never mentions any of them, leaving title, importPath, description, and referenceComponent completely unexplained. Only componentName/componentSource are faintly implied by the workflow.

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 (generates) and artifact (a CSF3 *.stories.tsx file) plus a secondary effect (remembers the component locally). It is immediately distinguishable from siblings like remember_component or list_stories.

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?

"Call after creating a new component" gives an explicit trigger point, and the note about other tools seeing it before Storybook is redeployed clarifies the timing rationale. It does not, however, name an alternative for the overlapping remember_component behavior.

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 full burden of behavioral disclosure. It does reveal that search spans multiple fields, which is useful context, but it does not describe matching semantics, sorting, pagination, or the response format. This is partial transparency at best.

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 that front-loads the action and resource. It is concise and readable, though it sacrifices useful detail for brevity.

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 no annotations, no output schema, and 0% schema description coverage, the description is too sparse. It does not explain the result shape, pagination, error behavior, or how limit affects results, leaving an agent without enough context to confidently invoke the tool.

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 0%, so the description must compensate. It does clarify that the query parameter searches across specific fields, but it does not explain query syntax or the limit parameter beyond its schema constraints. Some meaning is added, but important gaps remain.

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') with a clear resource ('stories') and lists the searchable fields: title, description, tags, sections, and content. This clearly distinguishes it from list_stories (listing) and get_story (fetching a specific story).

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 list_stories or get_story. The description implies a keyword-based search but does not state when list_stories would be more appropriate or when a direct get_story lookup should be used.

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, and it does reasonably well: it discloses the validation source of truth (Storybook argTypes) and the response behavior (reports invalid usage with suggestions), which implies a non-mutating check. It does not explicitly state that nothing is modified or that only the supplied snippet is analyzed, leaving a small 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?

A single sentence with the timing constraint front-loaded and no filler; every clause adds information (when to call, what is checked, what is returned).

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 validator with no output schema, the description covers what is checked and what the output contains (invalid usage plus suggestions). It could still clarify scope (snippet-only) and side-effect-free behavior, but nothing critical to invoking it correctly is missing.

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?

One parameter ('code') with 0% schema description coverage; the schema only gives type and length bounds. The description implies the input is the JSX/TSX to be validated, which partially compensates, but does not confirm format expectations (snippet vs. whole file) or size limits.

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 (validates/checks) and resource (JSX/TSX usage of design-system components), plus the exact validation dimensions (component names, props, enum values) and the reference source (Storybook argTypes). This is clearly distinguishable from siblings like list_components, get_component, or preview_story.

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?

Explicitly states the trigger condition – 'Call AFTER writing JSX/TSX that uses design-system components' – which is unusually clear timing guidance. It does not name a specific alternative or exclusion, so it stops short of a 5.

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