marmo-ui

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

With no annotations, the description must disclose behavioral traits. It mentions registration and URL generation, but lacks details on authentication requirements, destructive potential, rate limits, or side effects. The 'Marmo overlay' comment is vague and doesn't clarify behavior.

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 sentences only, with the core action in the first sentence and an additional feature in the second. No redundant words, and the structure is front-loaded with the main purpose.

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 simplicity (3 params, no output schema, no annotations), the description covers the basic purpose but omits important context like error cases, expected output format, and how this tool relates to siblings like get_prototype_feedback.

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 baseline is 3. The description adds no additional meaning beyond the schema; it does not explain how parameters like title or deployUrl affect the registration process.

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 registers a prototype for sharing and returns a share URL. It uses a specific verb ('register') and resource ('prototype'), and distinguishes its purpose from siblings like get_prototype_feedback by focusing on sharing and comment overlay.

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 guidance on when to use this tool vs alternatives. The description mentions reviewers can leave comments, implying it's for collaborative feedback, but does not specify exclusions or compare to sibling tools like get_prototype_feedback or generate_component.

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 full burden. It mentions validation and persistence but lacks details on error handling, side effects (e.g., overwriting), authorization requirements beyond 'authenticated tenant,' and rollback behavior. Critical for a mutation tool.

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

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

Two well-structured sentences with no waste. Action verbs are front-loaded, and the purpose is immediately clear.

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?

Covers basic purpose and validation prerequisite but lacks detail on return values, error scenarios, and persistence behavior. For a 4-parameter mutation tool with no output schema, 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 coverage is 100% with clear parameter descriptions. The description adds minimal additional meaning beyond stating the validation context. Baseline score of 3 is appropriate as schema does most of the work.

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 validates and optionally saves a custom component, mentions the prerequisite validation step using review_generated_code, and specifies usage for AI-generated or customized components. This distinguishes it from sibling tools like review_generated_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?

Explicitly states 'Use for AI-generated or customized components,' indicating when to use. However, does not provide exclusions or explicitly contrast with sibling tools like review_generated_code for validation-only use cases.

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?

Without annotations, the description carries full burden. It states the tool returns configuration but does not disclose behavioral traits such as side effects, rate limits, or formatting details. The simplicity of the tool mitigates this, but more transparency could be provided.

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 extremely concise with two sentences, each serving a purpose. It is front-loaded with the key action and resource, with no redundant information.

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's simplicity (one optional parameter, no output schema), the description provides sufficient context for usage. It could elaborate on the return format (e.g., 'returns a JSON configuration block') but is adequate for agents.

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% with one parameter described as 'Target agent client. Omit to get all configs.' The description adds value by naming the clients and providing usage context (Connect page), going beyond what the schema offers.

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 it returns MCP configuration for specific client tools (Cursor, Claude Code, Codex), providing a specific verb and resource that distinguishes it from sibling tools like deploy_prototype or generate_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 explicitly advises use on the Connect page or when setting up a new project, giving clear context. It lacks explicit exclusions or alternatives, but the sibling tools cover different purposes, making the guidance adequate.

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 provided, so description carries full burden. It discloses that the tool returns props with types/defaults, code examples, composition patterns, and common mistakes, and implies it is a safe read operation. No side effects or auth details needed for a read tool.

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 sentences, no unnecessary words, front-loaded with the main action and key requirement.

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 tool with no output schema, the description fully covers purpose, usage guidelines, return content, and parameter semantics. No gaps.

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 covers 100% of the single parameter, but the description adds value by specifying it's for a single @marmoui/ui component and linking to the requirement for first-time use.

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?

Description clearly states it retrieves detailed information (props, types, defaults, examples, patterns, mistakes) for a single @marmoui/ui component. It is distinct from siblings like list_components or search_components.

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 it is REQUIRED before first use of a component in a session to prevent hallucinated props, providing clear when-to-use guidance. Does not mention alternatives, but the context is strong.

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 provided, so the description carries the full burden. It describes what the tool returns (checklist, rules, patterns, icon library rules) but does not explicitly state it is read-only. However, the context implies no 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 dense paragraph but is well front-loaded with the mandatory call directive. It contains all necessary information without extraneous content, though some structure (e.g., bullet points) could improve readability.

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's purpose and two parameters, the description fully explains what is returned, the relationship with other tools (review_generated_code), and the required preliminary step (asking for icon library). No output schema exists, but the description compensates adequately.

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% with descriptions for both parameters. The description adds significant value: for iconLibrary, explains default behavior, user preference, and consistency with review_generated_code; for topic, mentions 'patterns' gets the generation checklist specifically.

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 it is a mandatory first call before writing UI code, returns a step-by-step generation checklist, critical rules, component patterns, and icon library rules. It distinguishes from siblings by being the initial required step.

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 marked as 'MANDATORY FIRST CALL' before writing UI code. Instructs the agent to ask the user which icon library they want and to pass the same value to review_generated_code. Provides clear when-to-use 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 provided, so the description bears full responsibility. It states the output is deterministic for a given tenant and implies a read-only operation. It does not disclose any side effects, authentication requirements, or rate limits, but the behavior is straightforward.

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 sentences: first states purpose and contents, second explains parameter usage and determinism. No wasted words, front-loaded with key information.

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 output schema, the description provides a reasonable overview of return values (DESIGN.md string or structured data) with a list of included fields. It could be more detailed about structure, but suffices for 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 100% for the single parameter. The description adds context about defaults and output contents, but does not significantly extend beyond the schema description. Baseline 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 clearly states the verb 'Generate' and the resource 'DESIGN.md' with specific contents (brand color, type, tokens, component inventory). It distinguishes from siblings like get_design_guidelines and get_tenant_theme by emphasizing a portable format for AI agents.

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 (to get a portable design specification for AI consumption) and provides two output formats. It doesn't explicitly say when not to use or name alternatives, but the context from siblings is clear enough.

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 fully covers behavioral traits: it's cheap to call, returns specific fields, and signals how to interpret results (unknown gitSha, far past indexedAt). No contradictions.

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 sentences, zero waste. Front-loaded with purpose, followed by usage instruction and edge-case handling. 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?

For a parameterless tool with no output schema, the description is complete: it names all return fields, explains cost, and provides actionable context. No gaps.

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?

No parameters exist (100% schema coverage vacuously). The description adds value by listing the return fields, compensating for the lack of output schema. Baseline for zero-param tools is 4, but the detailed field listing justifies a 5.

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 it returns MCP knowledge version including specific fields (gitSha, indexedAt, etc.). It uniquely identifies the tool's purpose and naturally distinguishes from siblings like get_component_info or get_design_guidelines.

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 instructs to call ONCE per session before generating UI code, explaining why (freshness). Also provides guidance on handling stale data by surfacing to user. This is among the best usage guidance seen.

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 discloses the return format ('code + inline validation report'), effects of iconLibrary parameter (icon rewrite), and conditional behavior for app-layouts (ASK USER). It lacks mention of error handling or prerequisites but is sufficient for a read-only getter.

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 concise, well-structured, and front-loaded. Every sentence provides useful information, from the main purpose to specific usage notes and return details.

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 two parameters and no output schema, the description adequately covers behavior, return structure, and special cases. It could mention error handling for invalid patternId, but the current description is reasonably 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 coverage is 100%, and the description adds value beyond the schema by providing examples for patternId, special instructions for 'app-layouts', and explaining the effect of iconLibrary on the output.

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 gets a 'complete, validated composition example for a common UI pattern', which is a specific verb+resource. It lists available patterns and differentiates itself from sibling tools like get_design_guidelines by focusing on pattern 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 context for when to use the tool (e.g., 'call app-layouts first for full pages', 'Pass iconLibrary') and behavior with no arguments. However, it does not explicitly mention when not to use it or compare to 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?

No annotations are provided, so the description must cover behavioral traits. It mentions the output format (structured data and Markdown) but lacks details on read-only nature, error behavior, rate limits, or permissions. The tool is likely read-only, but the description doesn't confirm this. It falls short of fully disclosing behavior.

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 comprises two short sentences that are concise and front-loaded with the key action. The second sentence adds a practical use case. No unnecessary words; every part is relevant. Slight improvement could be combining or adding structure, but overall efficient.

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 2 parameters, no output schema, and no annotations, the description gives the purpose and output format but omits details like pagination, error states, or whether it returns all comments. It is adequate for a straightforward tool but not fully complete. There is room to add more context.

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 50%: prototypeId has a description, includeResolved does not and only has a default value. The tool description adds no additional semantics beyond the schema, failing to explain what includeResolved means or how it affects results. With 50% coverage, the description should compensate but 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?

The description clearly states the action: 'Fetch inline comments from a shared prototype'. It specifies the resource ('prototype'), the output format ('structured data and Markdown'), and distinguishes from sibling tools like get_component_info or get_design_guidelines which deal with different aspects of the system. No ambiguity.

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 a use case ('Pull into Cursor/Claude to iterate on feedback') but does not explicitly say when to use this tool versus alternatives. There is no mention of prerequisites, when not to use it, or comparisons to sibling tools. The use case is implied but not formalized.

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; description indicates a read operation with no side effects. Mentions auth requirement but not explicitly. Adequate for a simple retrieval tool.

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 efficient sentences, front-loaded with purpose and followed by usage guidance. 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?

Simple tool with no parameters; description covers purpose, usage context, and output contents. No gaps 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?

No parameters; schema coverage is 100% vacuously. Description adds value by detailing what is returned, but param semantics baseline is high.

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?

Clearly states the tool returns the authenticated tenant's customized theme tokens, CSS variables, and component overrides. Distinguishes from sibling tools like get_component_info or get_design_guidelines.

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?

Provides explicit guidance to call after authentication to apply tenant-specific styling. Does not mention alternatives or exclusions, but the context is sufficient.

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 discloses that the tool lists all available components and includes specific fields. While it doesn't mention rate limits or pagination, the simple nature of a list tool makes this acceptable. It provides more detail than a bare description.

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 concise sentences, front-loaded with purpose and usage guidance. Every sentence earns its place with 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?

Given no output schema and no annotations, the description adequately covers purpose, usage, and parameter filtering. It hints at the return structure (names, descriptions, etc.), but could be more explicit about output format.

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% with clear descriptions for both parameters (status and category). The description adds no additional context beyond the schema, so baseline 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?

Description clearly states the verb 'List' and resource 'components', specifying the output fields (names, descriptions, categories, prop counts). It distinguishes itself from the sibling 'search_components' by noting the use case for discovery.

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 when to use this tool ('to discover what exists') and when to prefer the alternative 'search_components' (when you already know the use case like form, table, dialog). This is strong 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 fully covers behavioral aspects. It details what the tool catches (unknown imports, namespace misuse, PageSection usage, hallucinated props, icon library issues) and mentions output structure. Since it is a read-only validation, no destructive traits are relevant.

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 moderately long but every sentence contributes value. It is front-loaded with the mandatory warning, lists specific checks, and ends with a clear fix instruction. A minor reduction in verbosity could improve it, but it remains efficient.

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 output schema, the description explicitly mentions the return format (valid, errors, warnings, suggestedFixes, iconLibrary). It thoroughly covers what the tool does and what it checks, leaving no obvious gaps for a validation 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 coverage is 100%, but the description adds key context: code must import from @marmoui/ui, context helps targeted feedback, and iconLibrary should match get_design_guidelines' value, with wrong imports being errors. This adds significant 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 clearly states the tool validates TSX/JSX code against real prop signatures from @marmoui/ui, and lists specific checks. It is distinct from siblings like validate_component_usage by its mandatory nature and focus on generated 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?

Explicitly states it must be called on every piece of code before returning to the user, and instructs to fix errors and re-call if valid=false. While it does not discuss alternatives, the mandatory nature effectively communicates when to 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?

Discloses return of 5-8 most relevant components but contradicts schema's default limit of 10. No annotations present; description misses details on authentication, rate limits, or error 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?

Two concise sentences with no filler. Front-loaded with verb and resource, then examples and usage guidance.

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?

Covers purpose, relationship to sibling, and basic behavior. Lacks details on handle-no-results or output format, but sufficient for a simple search 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 has 100% coverage with descriptions. Description adds keyword examples and matching fields, adding some value beyond schema. The mention of 5-8 default contradicts schema's limit default of 10.

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?

Clearly states it searches by keyword and returns most relevant components. Distinguishes from sibling get_component_info by positioning as a discovery tool called before info 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?

Explicitly advises to call before get_component_info when unsure which component to use. Provides clear context but does not exclude alternative tools like list_components.

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 discloses the output format `{valid, issues[]}`, which is a key behavioral trait. However, it does not mention potential side effects or error handling, though for a read-only validation tool, this is largely sufficient. Score 4 because it adds value beyond the schema by specifying the return structure.

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 consists of two concise sentences. The first sentence states the core purpose and return type, followed by a second sentence that provides usage guidance. Every sentence is essential and front-loaded with the most critical information.

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's simplicity (two parameters, no output schema, no annotations), the description adequately covers purpose, return format, and usage guidance. It could be improved by mentioning error handling or performance considerations, but for a validation tool, the current content is largely 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 coverage is 100% as both parameters ('code' and 'iconLibrary') are fully described in the input schema. The description does not add any additional semantics beyond what the schema already provides, so baseline score 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 explicitly states the verb 'Validate' and the resource 'TSX/JSX snippet against real @marmoui/ui prop signatures'. It distinguishes from the sibling tool 'review_generated_code' by stating preference for post-generation review, making the purpose clear and differentiating it from similar 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?

The description provides explicit guidance on when to use this tool ('validating user-provided or existing code') and when not to ('prefer review_generated_code for post-generation review'). It names the alternative tool 'review_generated_code', offering clear usage boundaries.

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