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

With no annotations, the description carries the transparency burden. It does disclose exactly what it examines and which issue classes it detects, implying a read-only analysis, but it never explicitly states that the snippet is not modified, that no external systems are touched, or what the result looks like.

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 dense sentence front-loads the action, resource, and scope, then enumerates the detected issue types. 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 two-parameter audit tool with a fully described schema, the description supplies all selection-relevant detail: resource domains, optional scope, and target issues. The only minor gap is no explicit mention of the return/report format, but this is not needed to invoke it 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?

Schema coverage is 100%, so the baseline is 3. The description reinforces what codeOrQuery may contain and adds the issue-detection context, but it doesn't provide syntax/format details 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?

Opens with the strong verb 'Audits' and names four concrete resource classes (backend API code, database queries, network waterfalls, frontend rendering), followed by a specific list of issue types it hunts for. This clearly differentiates it from sibling audit_ux_compliance, which targets UX rather than performance/security.

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 establishes clear context: supply backend/database/network/frontend snippets to get a performance/security audit. It doesn't explicitly name alternatives or when not to use it, but the domain is unambiguous.

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 lists what criteria are audited but says nothing about the output format (e.g., report, pass/fail), whether it is read-only, side effects on input data, or any permissions required. For an audit tool, this is a significant gap.

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

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

The description is a single sentence that front-loads the verb 'Audits' and the target, then lists the many compliance criteria. It is efficient and not redundant, though the lengthy enumeration could be structured as a bullet list for readability. It earns a 4 for being focused and free of fluff.

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 complexity (many criteria) and lack of an output schema, the description fails to explain what the audit produces (e.g., a report, a score) or how the optional componentType parameter influences the audit. An agent cannot predict the return value or side effects, making the definition incomplete for practical use.

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

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

Schema description coverage is 100% – both parameters have clear descriptions in the input schema. The description itself does not add additional meaning beyond what the schema states; it merely lists audit dimensions. Baseline 3 is appropriate because the schema already documents the parameters adequately.

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 ('Audits') and resource ('UI code or prompt specs') and enumerates the exact compliance frameworks it checks against. It is instantly distinguishable from the sibling audit_system_performance (performance vs UX) and get_ux_guidelines (retrieval vs audit). No ambiguity in what this tool does.

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 you need a UX compliance audit), but it does not explicitly contrast with alternatives like get_ux_guidelines or audit_system_performance. There is no mention of when not to use it or how it differs from sibling tools, leaving the agent to infer based solely on the name and wording.

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 states that the tool retrieves multiple artifact types and supports fallback live fetching, which conveys a read-only, network-capable operation. It does not detail error behavior, but for a simple retrieval tool the core behavior is transparent enough.

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-load the core purpose and add the fallback behavior without any filler. Every clause contributes useful 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?

For a two-parameter retrieval tool with no output schema, the description sufficiently explains what will be returned and the fallback mechanism. It lacks only minor details like error behavior or exact response structure, but the essential calling context is covered.

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 the schema already documents both slug and registryUrl. The description adds minimal parameter-level meaning beyond noting fallback live fetching, which aligns with the registryUrl schema description. Baseline 3 is appropriate because the description does not need to compensate.

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 ('Retrieves') and a concrete resource ('complete React, Tailwind, Framer Motion source code, demo, and dependencies for a component'). This clearly distinguishes it from sibling tools like search_ui_components, which search rather than retrieve 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?

The description implies the tool is used when you need source code for a specific component, but it gives no explicit when-to-use or when-not-to-use guidance, nor does it mention alternatives such as search_ui_components for discovering a slug. Usage context is implied rather than stated.

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

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

No annotations are provided, so the description must carry the behavioral disclosure burden. It implies a read operation via 'Provides' and the 'get' verb, but does not explicitly state that it is read-only, idempotent, or free of side effects. For a simple getter this is adequate, but it lacks explicit safety guarantees.

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 core purpose and lists all relevant categories. There is no fluff or redundancy, though it is slightly list-heavy.

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 get tool with one enum parameter and no output schema, the description covers the main token categories adequately. It does not provide examples or format details, but those are not strictly necessary given the tool's simplicity and the schema's completeness.

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 fully documents the single 'category' parameter with an enum and description, achieving 100% schema description coverage. The tool description adds no additional semantic detail beyond listing the categories, so the baseline score of 3 applies.

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

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

The description specifies the exact resources: HSL CSS color variables, globals.css setup, typography scales, spatial grid, icon stroke rules, shadows, and spring animation parameters. This clearly differentiates it from sibling tools like get_layout_blueprint and get_ux_guidelines, which likely focus on other aspects of the design system.

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. It only lists what it provides, leaving the agent to infer the appropriate context. No exclusions or conditions are mentioned.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. 'Retrieves' does establish a read-only operation and the content categories are explicit, but the description nothing about behavior when parameters are omitted or how optional parameters interact, and it does not mention error or fallback 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?

A single dense sentence front-loads the verb and primary resource, with the remaining space devoted to useful examples. There is no filler 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?

For a simple 2-parameter retrieval tool the description is mostly adequate, but it does not disclose the default behavior when no `id` or `type` is provided, and the distinction between returning one blueprint vs a filtered list is unclear. With no output schema and no annotations, that is a meaningful ambiguity.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value by distinguishing the two retrievable resource types — macro layout scaffolds vs task patterns — which isn't fully spelled out in the schema's enum alone. The parenthetical examples reinforce the categories an agent can expect to find.

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 opens with a specific verb ('Retrieves') and clearly names the resources: NN/g IA macro page layout scaffolds and Design System Task Patterns. The listed example patterns (AI Co-pilot generation, Destructive actions, SaaS Dashboards, Settings, Onboarding, Pricing) make the tool's scope concrete and distinguish it from siblings like get_ux_guidelines, get_component_code, or get_design_tokens.

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 about when to use this tool versus alternatives. It does not name any sibling tools or exclude situations, so an agent must infer the usage context from the content list alone.

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

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

With no annotations present, the description carries the burden of disclosing behavior, but only states that the tool 'queries' rules; it does not say whether results are exhaustive, how multiple frameworks are combined, or what output is returned. There is no warning about side effects, permissions, or limits.

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 core purpose is front-loaded in a single sentence, with the framework list at the end. It is slightly long due to the enumeration, but each listed framework is useful search context, and there is no redundant fluff.

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 schema fully covers the two optional inputs, and the description names the knowledge base being queried, so calling the tool is straightforward. However, there is no output schema and the description never explains return shape or empty-result behavior, leaving an agent to guess at the response for a multi-framework query.

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?

Both parameters are already documented in the schema with descriptions and examples, so schema coverage is 100%. The description itself adds no extra meaning about topic or category beyond the schema, so the baseline score of 3 applies.

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

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

The description opens with a specific verb ('Queries') and a resource ('UX Intelligence Rules'), then enumerates the covered frameworks, so an agent can tell this is a lookup/retrieval tool. It does not explicitly contrast with siblings, but the named scope is enough to distinguish it from audit_ux_compliance and search_ui_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?

The description gives no explicit when-to-use or when-not-to-use guidance, and never mentions alternatives or conditions for choosing get_ux_guidelines over audit_ux_compliance or search_ui_components. An agent must infer appropriate usage from the name and schema alone.

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

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

The wording 'Searches' indicates a non-mutating operation, and naming the registry gives useful context beyond the schema. However, with no annotations and no output schema, it does not disclose how results are returned, whether multiple filters combine, or any service limitations.

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

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

A single, front-loaded sentence states the operation, resource, and search criteria without redundancy. Every clause contributes meaning, and there is 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 simple search tool with three optional parameters, the description covers the core purpose and source. It falls short by not explaining result behavior, parameter combination logic, or how this step relates to subsequent tool calls like get_component_code.

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 67%, with tag and query having examples and category only having an enum. The description adds mild value by grouping all three fields as search dimensions, but it does not clarify whether parameters are mutually exclusive or combinable, nor does it describe category 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 uses a specific verb ('Searches'), names the resource ('21st.dev & curated high-craft UI component registry'), and lists the three search dimensions: keyword, category, or tag. It is clear and scoped, though it does not explicitly contrast itself with siblings like get_component_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?

No guidance is given about when to choose this tool over alternatives, such as get_component_code for fetching a specific component's implementation. The description implies general search usage but does not state prerequisites, exclusions, or preferred sibling routing.

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