marmo-ui

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

With no annotations provided, the description carries the full burden. It discloses a key behavior (register and get share URL) and a feature (inline comments via Marmo overlay), but does not mention side effects, permissions, or what happens on existing prototypes. This is a moderate level of transparency.

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

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

Two sentences, each informative and front-loaded. The first sentence states the core function, the second adds a relevant detail. 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 simple registration tool with 3 parameters and no output schema, the description covers the essential context: what it does, what it returns (share URL), and an extra feature. It could be more complete about return structure or error conditions, but it is adequate for basic selection.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters (title, deployUrl, prototypeId) with descriptions. The tool description adds no extra parameter semantics, but the baseline of 3 is appropriate because the schema is sufficient.

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's action ('Register a prototype for sharing') and its output ('get a share URL'). It also distinguishes itself from siblings by focusing on deployment/sharing, whereas siblings like get_prototype_feedback are for retrieving feedback.

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 used when sharing a prototype, but it does not explicitly state when to use it versus alternatives (e.g., when to use get_prototype_feedback instead). No exclusions or prerequisites are mentioned.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does disclose the key flow: validation first, then optional persistence ('Runs review_generated_code validation before persisting'). However, it does not explain what happens if validation fails, whether saving overwrites existing components, or what the response looks like. This is partial transparency, enough for basic understanding but lacking critical side-effect 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?

The description is concise and well-structured. It opens with the core purpose, adds a key behavioral detail, and ends with usage guidance. All three sentences contribute unique information without redundancy, making it easy to parse and act upon.

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 4 parameters, no output schema, and no annotations. The description covers what the tool does, when to use it, and the validation-before-save flow, which is sufficient for selecting and invoking the tool. However, it does not describe return values or error handling, which would be useful given no output schema exists. Overall, it is reasonably complete for a simple tool, but not fully comprehensive.

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 input schema already provides descriptions for all 4 parameters (100% coverage), so the baseline is 3. The tool description does not add significant semantic detail about parameters; it only mentions validation before saving, which indirectly relates to the 'code' and 'save' parameters but does not elaborate on their meanings or formats. No extra value 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's function: 'Validate and optionally save a custom component for the authenticated tenant.' It uses specific verbs (validate, save) and a specific resource (custom component), and distinguishes itself from the sibling tool 'review_generated_code' by noting that it runs that validation before persisting. This makes the purpose unambiguous and differentiates 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 clear usage context with 'Use for AI-generated or customized components,' indicating when this tool is appropriate. It also implies an alternative by mentioning it runs review_generated_code validation before persisting, but it does not explicitly state when to use review_generated_code alone or give exclusion criteria. This is clear context without explicit alternatives, earning a 4.

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. 'Returns' implies a safe, read-only operation and 'ready-to-paste' adds useful output-format context. However, it does not disclose auth requirements, error behavior, or output structure in a way that fully compensates for the missing annotations.

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, 24 words, zero waste. The first sentence is front-loaded with the tool's core function and output, and the second adds targeted 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?

This is a simple tool: one optional parameter, no output schema, no annotations. The description covers what it returns, for which clients, and when to use it. The 'ready-to-paste' phrasing gives a sense of the output format. For a straightforward config getter, this 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% — the 'client' parameter already has an enum and description ('Target agent client. Omit to get all configs.'). The description mentions the three agent clients, reinforcing the enum, but adds little beyond what the schema already provides.

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 ('Returns') and a specific resource ('ready-to-paste MCP configuration') with explicit target clients (Cursor, Claude Code, or Codex). This clearly distinguishes it from all sibling tools, which focus on components, design, patterns, and deployment.

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 clear usage context: 'Use on the Connect page or when setting up a new project.' It does not explicitly name alternatives or state when not to use the tool, but for a config retrieval tool with clearly differentiated siblings, 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?

There are no annotations, so the description carries the full burden. It discloses the tool's output (props, types, defaults, examples, composition, mistakes) and its mandatory role in the workflow. It also warns about build-time failures from skipping it, adding useful behavioral context. It doesn't mention auth or side effects, but as a read-only info tool this is adequate.

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, both purposeful. The first sentence front-loads the action and deliverables. The second sentence adds a clear usage mandate and rationale. No redundancy or filler.

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

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

With a single simple parameter, no output schema, and no annotations, the description needs to explain what the tool returns and when to use it. It lists the content types (props, types, defaults, examples, composition, mistakes) and the timing requirement. This fully covers the necessary context for an agent to use 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?

The input schema already provides a clear description for componentName with examples (e.g. 'Button', 'Card', 'Input'). Since schema description coverage is 100%, the tool description adds no additional parameter-level meaning. 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 tool's function with a specific verb and resource: 'Get exact props (with types and defaults), code examples, composition patterns, and common mistakes for a single @marmoui/ui component.' It distinguishes itself from siblings like list_components and search_components by focusing on detailed info for a single named 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 provides explicit when-to-use guidance: 'REQUIRED before using any component for the first time in a session.' It also explains the benefit (prevents hallucinated props that fail at build time). However, it does not explicitly mention when not to use it or name alternatives, so it lacks exclusionary 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It does not explicitly state side effects, but as a read-only retrieval tool, the absence of mutation is implied. It discloses that it returns a checklist and rules, and mentions the default iconLibrary behavior and the need to ask the user, which adds useful behavioral context.

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 dense but well-structured, front-loading the most important instruction ('MANDATORY FIRST CALL'). Some sentences are long and combine multiple details, but every sentence contributes useful information. It could be broken into clearer paragraphs, but it's still efficient and not wasteful.

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 there is no output schema, the description fully explains what the tool returns: a checklist, critical rules, patterns, and icon library specifics. It also covers the key workflow aspects (order, icon library selection, topic filtering) and connects to review_generated_code. This is arguably over-complete for a guidelines retrieval tool, leaving no obvious 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?

The schema already provides descriptions for both parameters, so the baseline is 3. The description adds extra value by explaining the iconLibrary default, naming supported values, advising to pass the same value to review_generated_code, and highlighting topic='patterns' for the generation checklist specifically. This goes beyond the schema's basic descriptions.

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 returns a step-by-step generation checklist, critical rules, component patterns, and icon library rules. It uses a specific verb ('get') and resource ('design guidelines'), and distinguishes itself from siblings like get_component_info and get_pattern by positioning itself as the mandatory first call.

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 says 'MANDATORY FIRST CALL before writing any @marmoui/ui code in this session,' providing strong when-to-use guidance. It also instructs to ask the user about icon library before writing code and to pass the same value to review_generated_code, offering clear workflow 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 full burden. It discloses that the output is deterministic for a given tenant, portable, and readable by any AI agent. It also outlines what content is included. It does not explicitly state that the operation is read-only, but the generation semantics and lack of mutation hints make it reasonably transparent.

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 three sentences, front-loaded with the core purpose, then format guidance, then a behavioral note about determinism. Every sentence adds value and there is no fluff 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?

Despite having no output schema, the description explains both return types (markdown string or structured data) and highlights key behavioral aspects (determinism, portability) that are essential for an agent. It is complete for a simple single-parameter tool, though it could mention error scenarios or authentication requirements beyond 'authenticated tenant'.

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

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

The schema has 100% coverage with a detailed description for the 'format' parameter. The tool description essentially repeats the schema description ('Pass format="markdown" (default) for the DESIGN.md string or format="json" for structured data'), adding no extra meaning. A baseline of 3 is appropriate when the schema already documents the parameters.

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 ('Generate') and resource ('portable DESIGN.md') with detailed content (brand color, type, tokens, component inventory). It distinguishes itself from sibling tools like get_design_guidelines and get_tenant_theme by focusing on a consolidated, agent-readable design document.

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 clear context: it is meant for generating a portable DESIGN.md for an AI agent. It explains format options and defaults, implying when to use markdown vs json. However, it does not explicitly mention exclusions or alternatives, such as when to use get_design_guidelines or get_tenant_theme instead.

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. It discloses that the call is 'Cheap to call' (performance cost), and explains how to interpret the results, including a conditional action ('surface that to the user'). While it doesn't explicitly state read-only safety, the nature of returning metadata and the advice to surface issues implies non-destructive behavior. It adds useful context beyond a bare return-type statement.

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 three sentences: the first states the purpose and output, the second provides timing guidance, and the third covers conditional handling. Every sentence adds distinct value with no wasted words. It is front-loaded with the primary action and output, making it instantly scannable.

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

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

For a simple, zero-parameter tool with no output schema, the description is fully adequate. It covers what is returned, when to call it, the cost implication, and how to handle stale data. There are no missing prerequisites, side effects, or response-format concerns that need addressing for this tool to be used 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?

The input schema has zero parameters, and the context signal shows 100% schema description coverage. The baseline for 0 params is 4. The description adds no parameter details, which is appropriate because there are none to describe. It also doesn't need to compensate for any missing parameter information.

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 begins with 'Returns the MCP knowledge version' and enumerates the specific fields (gitSha, indexedAt, componentCount, patternCount, uptimeSeconds), making the resource and output explicit. This clearly distinguishes it from sibling tools, none of which appear to provide version or freshness 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?

Explicit usage guidance is given: 'Call this ONCE per session before generating UI code so you know how fresh the design-system data is.' It also instructs when to surface a warning to the user if the data is stale, covering when to act on the result. No alternatives are needed since no sibling tool serves a similar purpose.

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 discloses return contents (code + inline validation report), the app-layouts selection flow, and how iconLibrary affects the output. It does not explicitly state read-only behavior, but the 'get' verb and overall framing imply it strongly.

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 paragraph that is information-dense but not rambling. Every sentence contributes to understanding the tool's behavior. It could be improved with bullets for readability, but it remains efficient and well-structured.

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 covers all critical aspects: purpose, available patterns, special flow, parameter effects, return value, and how to list all patterns. It is sufficiently complete for an agent to invoke the tool correctly without additional 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 coverage is 100%, giving a baseline of 3. The description adds meaning by explaining the effect of iconLibrary ('so the usage note tells you which icon import source to rewrite the pattern's icons to') and reinforces the omit-to-list behavior, providing value 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 retrieves a 'complete, validated composition example for a common UI pattern,' with an explicit list of available patterns. This distinguishes it from sibling tools like get_component_info or get_design_guidelines by focusing on pattern-level compositions rather than individual components or 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?

The description gives clear usage context, including special instruction to 'Call app-layouts first for full pages' and to 'Call with no arguments to list all patterns.' It does not explicitly name alternative tools or state when not to use it, but the context is strong enough for an agent to apply correctly.

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 adds context by specifying the output format (structured data and Markdown) and the resource (inline comments), but does not disclose default behavior for resolved comments, authentication requirements, or any side effects. This leaves some gaps for a fetch 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?

The description is two sentences, front-loaded with the core purpose and output format. The second sentence adds a useful workflow hint without redundancy, making it appropriately sized and well-structured.

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 is simple with two parameters and no output schema. The description covers the main purpose and output format, but lacks details on return structure, includeResolved behavior, or error conditions. It is adequate for a basic fetch tool but not fully complete in 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?

The description adds context for prototypeId by referencing 'shared prototype' and 'inline comments', but it does not mention the includeResolved parameter, which remains undocumented in both the schema and description. With schema description coverage at 50%, the description partially compensates but does not fully clarify all parameters.

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 fetches inline comments from a shared prototype, using a specific verb ('Fetch') and resource ('inline comments from a shared prototype'). It distinguishes itself from sibling tools like get_component_info or get_design_md by focusing on prototype feedback, and adds output format context (structured data and Markdown).

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 a usage scenario ('Pull into Cursor/Claude to iterate on feedback') but does not explicitly state when to prefer this tool over alternatives or provide exclusions. It gives a workflow hint but lacks comparative guidance, so usage is implied rather than clearly delineated.

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 discloses the type of data returned (tokens, CSS variables export, component overrides) and notes the dependency on authentication. It doesn't mention side effects, but the read-only nature is implied by 'Returns,' and the description adds useful context beyond just the tool name.

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

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

The description is two efficient sentences: the first states exactly what the tool does, the second provides the usage context. Every word earns its place, with no filler or redundancy. It is front-loaded with the most important 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 zero parameters and no output schema, the description provides sufficient context: it names the three types of outputs and the timing (after auth). This is complete for an agent to select and invoke the tool correctly, especially compared to similar tools in the catalog.

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

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

The tool has zero parameters, so the baseline is 4. The description correctly avoids inventing parameter details and instead focuses on the output. No additional parameter explanation is needed or expected.

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 exact purpose: returning the authenticated tenant's customized theme tokens, CSS variables export, and component overrides. The verb 'Returns' plus the specific resource (tenant's theme) makes it unambiguous and distinguishes it from sibling tools like get_design_guidelines or get_pattern.

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 says 'Call after auth to apply tenant-specific styling in generated code,' which provides a clear usage context (after authentication for styling in generated code). It doesn't explicitly exclude alternatives or name when not to use it, so a small gap remains, but the guidance is specific enough for most agents.

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

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

No annotations are provided, so the description carries the full behavioral burden. It states the output fields but does not explicitly confirm read-only status, pagination behavior, or how the optional filters interact with the 'List all' statement. Adequate but lacking richer behavioral context.

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 three concise sentences: what it does, when to use it, and which alternative to prefer. Each sentence earns its place with no repetition or 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 simple read-only listing tool with no output schema, the description covers purpose, usage, and return fields. It does not mention pagination or how to combine filters, but these are minor gaps given the tool's simplicity. Slightly incomplete due to the lack of explicit read-only confirmation and filter behavior guidance.

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 'status' and 'category' parameters. The description adds minimal extra meaning, only implying an unfiltered list by default. Since the schema already documents the parameters, the baseline of 3 is appropriate.

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

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

The description clearly states the tool lists all available @marmoui/ui components with specific fields (names, descriptions, categories, prop counts). It explicitly distinguishes from search_components by presenting an alternative, making the purpose unambiguous.

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

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

The description provides explicit guidance: 'Use to discover what exists' and 'Prefer search_components when you already know the use case'. This gives clear when-to-use and when-not-to-use context, naming the sibling tool as an alternative.

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 fully carries the transparency burden and meets it exceptionally. It discloses the return shape, enumerates five specific error categories, explains the auto-suggest fix for Tabs namespace misuse, and defines that wrong-library icon imports are errors. This is far beyond a typical tool 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?

Though long, every sentence is high-signal. The mandatory directive is front-loaded, the numbered catches make complex rules scannable, and the closing prohibitions are unambiguous. No filler or redundancy; the structure earns its length.

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

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

With no output schema, the description correctly explains the return object and its fields. It covers the necessary preconditions (complete code, import from @marmoui/ui), the expected parameters, and the iterative workflow. For a tool of this complexity, nothing significant 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?

Schema coverage is 100%, so baseline is 3. The description adds meaningful semantics for iconLibrary by linking it to get_design_guidelines and clarifying that mismatched imports are errors. Code and context parameters are adequately described in the schema, so the extra value for iconLibrary pushes this to a 4.

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: 'Validates TSX/JSX against real @marmoui/ui prop signatures'. It clearly differentiates from siblings by framing itself as a mandatory pre-return step for generated code, not just a general validation tool. The scope and outcome are unmistakable.

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 when-to-use guidance: 'MANDATORY — call this on every piece of code you generate before returning it to the user', plus a clear feedback loop ('If valid=false, fix all errors and call this again') and a hard rule ('DO NOT return code with errors'). It also instructs matching iconLibrary with get_design_guidelines, which is actionable 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?

The description discloses the behavior of returning the '5-8 most relevant components', but this conflicts with the schema's default limit of 10, creating ambiguity. With no annotations, the description must fully describe behavior, and this inconsistency is a 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?

Two sentences, front-loaded with the action and purpose, and includes a clear usage directive. No filler or redundancy.

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

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

For a search tool, it explains when to use it, what it returns, and how it relates to get_component_info. However, it does not clarify the discrepancy between the stated '5-8' results and the limit parameter, nor does it distinguish from list_components, leaving slight 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 covers both parameters with descriptions, and the description adds example keywords. However, it does not elaborate on the limit parameter or the matching behavior beyond schema, so it adds minimal value beyond the baseline.

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 searches @marmoui/ui by keyword for relevant components, using specific examples like 'form' and 'table'. It distinguishes itself from get_component_info by advising to call it first when unsure which component to use.

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 the 'Preferred discovery tool' and instructs to call it before get_component_info when in doubt. This provides clear when-to-use guidance relative to a sibling tool.

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 return shape ('{"valid, issues[]"}') and implicitly signals read-only behavior by contrasting with review_generated_code's auto-fix capability. It could explicitly state that it does not modify code, but the validation intent is clear.

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 three sentences, front-loaded with the core action, then return shape, then usage guidance. Every sentence contributes unique value with no redundancy or 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 2-parameter tool with no output schema, the description covers purpose, usage boundaries, and basic return shape. It does not detail the structure of 'issues[]', but this is a minor omission given the tool's simplicity. Overall, it is nearly complete for this complexity level.

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 both parameters (code and iconLibrary) are already well-documented in the schema. The description adds no parameter-specific information beyond what the schema already provides, which meets the baseline.

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 ('Validate') and resource ('TSX/JSX snippet against real @marmoui/ui prop signatures'), making the tool's function unmistakable. It also explicitly contrasts with 'review_generated_code', distinguishing it from a key sibling.

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

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

The description gives explicit when-to-use guidance: 'Prefer review_generated_code for post-generation review' and 'Use this tool when validating user-provided or existing code rather than newly generated code.' This leaves no ambiguity about the intended context.

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