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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description adds value by noting that inferences are marked clearly, which is a behavioral trait about the output format. No contradiction with 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?

The description is a single sentence, front-loaded with the primary verb, and conveys the essential information without redundancy. The list of output contents is slightly dense but does not include 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?

The tool has an output schema, so return format is covered. However, the description does not explain the role of optional parameters or how they influence the brief, and it lacks differentiation from sibling tools. It is adequate but has clear gaps in parameter semantics and usage boundaries.

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

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

Schema description coverage is 0%, so the description must compensate for parameter meanings. It only references product_description and constraints, leaving aesthetics, performance, accessibility, and target_framework unexplained. This provides little value beyond the schema's bare parameter names.

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 ('Build an implementation brief') and resource, with a specific list of contents (stack, components, motion system, design tokens, etc.). This distinguishes it from sibling tools like search_frontend_knowledge or recommend_frontend_stack, which focus on discovery or recommendations rather than building a brief.

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 clear use case: generate a brief from product_description and constraints. It provides context but does not explicitly mention when not to use it or name alternatives. While no exclusions are stated, the clear input conditions are sufficient to guide usage.

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?

Beyond the readOnlyHint and idempotentHint annotations, the description discloses behavioral traits: it separates facts from inferences and never claims unverified compatibility. It also notes the deprecated `resources` alias, adding context about backward compatibility. No contradiction with 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?

The description is only three sentences with the main purpose in the first sentence. Each subsequent sentence adds value without redundancy, making it 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?

The description covers the core purpose and primary parameter, and the output schema likely handles return values. However, it omits the `criteria` parameter semantics and does not explicitly state when to use this tool versus alternatives, leaving some gaps for safe invocation.

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

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

The description explains `options` as a list of ids/names and identifies `resources` as a deprecated alias. However, with 0% schema description coverage, the `criteria` parameter is not mentioned at all, leaving a significant gap in parameter understanding.

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 compares frontend options using id or name, which is a specific verb+resource. This distinguishes it from sibling tools like discover_frontend_resources or recommend_frontend_stack, which have different actions. The mention of 'Separates facts from inferences' adds further specificity.

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 that the tool is used for comparing a list of options and explains the primary parameter and deprecated alias. However, it does not explicitly state when not to use it or name alternatives, leaving exclusion logic to the agent.

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 annotations already establish read-only and idempotent behavior. The description adds useful behavioral context by stating that results are paginated and include provenance, which goes beyond the annotations and input schema. It does not contradict any annotations and provides a clear sense of what the tool returns.

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 with no filler. The first sentence defines the tool's purpose, and the second lists supported filters and return characteristics, efficiently packing information without unnecessary detail.

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

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

For a read-only tool with annotations and an output schema, the description provides a solid overview: what it browses, what filters are available, and that results are paginated with provenance. However, parameter semantics remain thin, and the description could briefly hint at how filters compose, though this is partly mitigated by the presence of an output schema.

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?

With 13 parameters and 0% schema description coverage, the description carries a heavy responsibility. However, it merely lists the parameter names (category/kind, framework, style/tags, etc.) without explaining their meanings, expected values, or how they interact. This adds minimal semantic value beyond the schema's type definitions.

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 specific verbs ('Browse and filter') and a well-defined resource type ('indexed frontend resources' with components, patterns, libraries). It also lists the supported filter dimensions, which distinguishes it from sibling tools that target narrower categories like find_components or find_animation_patterns.

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 general browsing/filtering use case but provides no explicit guidance on when to use this tool versus alternatives such as find_components or search_frontend_knowledge. It does not state when not to use it or mention any prerequisites, leaving the agent to infer the appropriate context without clear exclusions.

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?

Annotations already cover readOnlyHint and idempotentHint, so the description adds value by disclosing that results come from indexed notes ('when known from indexed notes') and that sources are cited. This clarifies the knowledge scope and output behavior beyond the structured 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?

The description is two concise sentences, front-loaded with the primary purpose. Each sentence adds meaningful information—what the tool does and what the results include—with no redundant wording or unnecessary detail.

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

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

The presence of an output schema and annotations covers return values and safety, but the 0% parameter description coverage leaves gaps. The description does not explain the limit and framework parameters, making the tool's usage incomplete for an agent attempting 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 description coverage is 0%, so the description must explain parameters. It only mentions 'query/use-case', which maps to query and use_case, but leaves 'limit' and 'framework' unexplained. The bare property names offer some hint, but the description fails to compensate for the lack of schema 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 finds animation patterns for a query/use-case, using a specific verb and resource. It further distinguishes from sibling tools by listing unique features like cost notes, accessibility, prefers-reduced-motion support, and source citations.

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 for when to use the tool: when one needs animation patterns, and what results will include. It does not explicitly name alternative tools or state exclusions, but the usage context is unambiguous and actionable.

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?

Annotations already declare readOnlyHint and idempotentHint, so the agent knows this is a safe read operation. The description adds context about intent strings and framework filtering, but does not disclose search behavior, result size limits, or other operational details beyond the 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?

The description is a single concise sentence that front-loads the main purpose and includes parenthetical examples. Every word contributes, with 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?

The tool is simple with three parameters and an output schema. The description covers the key inputs (intent, framework) and provides a clear functional overview. The only missing piece is the limit parameter and any explicit usage context, but given the output schema and low complexity, the description 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?

With 0% schema description coverage, the description must compensate. It explains the intent and framework parameters (intent string, optional framework filter), but does not mention the limit parameter. Since limit likely controls the number of results, the agent may have to guess its meaning, leaving a partial gap.

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 finds components/patterns for an intent string, with specific examples (hero, pricing, navbar) and an optional framework filter. This verb+resource+scope structure distinguishes it from sibling tools like find_animation_patterns and discover_frontend_resources.

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

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

The description implies usage for intent-based component discovery and mentions an optional framework filter, but it does not explicitly state when to use this tool over alternatives like find_animation_patterns or search_frontend_knowledge. There is no exclusion or when-not-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?

Annotations already declare readOnlyHint and idempotentHint, so the safety profile is covered. The description adds valuable behavioral context beyond annotations: it never returns credentials and redacts database URLs. It also clarifies that it reports dynamic server state, which is useful but not heavily detailed.

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: a brief opening sentence summarizing the purpose, followed by a clear enumeration of what it reports and a safety note. Every sentence adds value without redundancy or fluff, making it 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 zero-parameter tool with an output schema, the description covers the essential aspects: backend, retrieval modes, embedding provider, index counts, and security redaction. It is sufficiently complete for an agent to decide when to call it and what to expect.

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 doesn't need to add parameter semantics, and it appropriately focuses on the tool's behavior and output. There is nothing to compensate for.

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 performs a 'Readiness check' covering storage backend, retrieval mode, and index counts. It uses a specific verb and resource, and the scope ('what the server can actually do right now') distinguishes it from sibling tools like front_design_ping (liveness) and discover_frontend_resources.

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

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

The description provides clear context for when to use the tool: to check current backend availability, search modes, and embedding provider configuration. It implies usage for readiness assessment but does not explicitly mention alternatives or exclusions, so it lacks the highest level of 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?

Annotations already declare readOnlyHint=true and idempotentHint=true, and the description adds the specific data fields returned. This is consistent with annotations and adds useful context beyond them, though it doesn't describe potential error 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 is a single sentence that is front-loaded with the core purpose ('Liveness check') and includes only essential details. 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, no-parameter ping tool with an output schema and clear annotations, the description is adequate. It could benefit from a note distinguishing it from the similarly named 'front_design_health' sibling, but overall it covers the essential information.

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

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

The tool has zero parameters, and schema description coverage is 100%. The baseline for no-parameter tools is 4, and the description doesn't need to explain 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 the tool performs a liveness check and specifies what it reports (package version, runtime mode, indexed resource count). However, it does not explicitly distinguish itself from the sibling 'front_design_health' tool, so it lacks explicit sibling differentiation.

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

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

The phrase 'Liveness check' implies a quick health verification, providing some usage context. However, there is no explicit guidance on when to use this tool versus alternatives such as 'front_design_health'.

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?

Annotations already declare readOnlyHint and idempotentHint, so the description doesn't need to cover safety. It adds meaningful behavior beyond annotations: that the result is 'normalized', includes 'sanitized documentation chunks', and returns 'license/attribution'. This clarifies what the agent will receive. It does not mention not-found behavior, but for a simple fetch this is acceptable.

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, tightly written sentence that front-loads the primary action and object. Every clause adds value: normalized resource, id example, related sanitized chunks, license/attribution, and parameter name. 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 the tool's low complexity (1 parameter) and the presence of an output schema, the description covers all essential context: what is fetched, the id format, and additional returned data. It is sufficiently complete for an agent to select and invoke the tool correctly without further 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?

The schema only provides 'id' as a bare string. The description adds crucial semantics with the phrase 'resource id string, e.g. motion:motion-library', giving a concrete example of the expected format. It also explicitly names the parameter, making the relationship between description and schema crystal clear. This fully compensates for the 0% schema description coverage.

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

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

The description uses a specific verb ('Fetch') and clearly identifies the resource ('normalized FrontendResource by id') plus additional related content (documentation chunks, license/attribution). It distinguishes itself from sibling search/discovery tools by emphasizing lookup by exact id rather than free-form search.

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 clearly implies the use case: when you have a resource id. It provides an example id format to guide correct usage. However, it does not explicitly state that you should use this instead of search when you have an id, nor does it mention any exclusions. Still, the context is clear and the example anchors the intended usage.

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?

Annotations already declare readOnlyHint=true and idempotentHint=true, covering safety. The description adds behavioral context by specifying the return content (recommendation, trade-offs, incompatibilities, plan, sources) and the fact vs. inference distinction, which helps the agent set expectations. No contradiction with 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?

The description is a single long sentence that front-loads the core purpose and then enumerates inputs and outputs. It is efficient with no filler, though splitting into two sentences would improve readability slightly.

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 output schema exists and annotations are present, the description covers the essential purpose, inputs, and output structure well. It lacks explicit usage alternatives and deeper parameter explanations, but overall it provides sufficient context for correct invocation.

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

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

Schema description coverage is 0%, so the description must compensate, but it only lists parameter names without explaining semantics or formats. For example, it does not say what 'requirements' should look like, how 'constraints' should be structured, what 'limit' does, or any parameter-specific guidance. The mention of parameters adds minimal value beyond the schema types.

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 action with a clear target: 'Recommend a frontend stack' and lists all relevant input dimensions (requirements, target_framework, constraints, aesthetics, accessibility, performance). It distinguishes itself from siblings like compare_frontend_options (which compares) and build_frontend_brief (which builds brief) by focusing on recommendation and specifying outputs.

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 usage context is implied by the description (use when you have these inputs and need a recommendation), but it does not explicitly state when to use this tool versus alternatives such as compare_frontend_options or search_frontend_knowledge. There are no exclusions or 'when not 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?

Annotations already declare readOnlyHint=true and idempotentHint=true, so the description adds valuable context beyond these by disclosing the underlying retrieval backends (SQLite BM25 and PostgreSQL hybrid with pgvector) and the return structure (scores, per-branch ranks, retrieval mode, citations, provenance). This gives the agent a richer understanding of the tool's behavior without contradicting the 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?

The description is three sentences long, front-loaded with the main purpose, and each sentence adds meaningful detail. There is no redundancy or filler; it achieves high information density in a compact form.

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 (7 parameters, conditional backend behavior, and a rich return payload), the description covers the essential aspects: retrieval modes, filters, detail_level options, and output contents. The presence of an output schema covers the exact return structure, so the description need not list every field. It does not mention the default limit or specific prerequisites for the hybrid backend, but these are minor 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?

With schema description coverage at 0%, the description carries the burden of parameter explanation. It lists all parameters (query, kind, framework, tags, source_id, limit, detail_level) and groups the optional ones as filters, and it defines the allowed values for detail_level (brief|standard|full). However, it does not elaborate on the meaning of each filter (e.g., what values 'kind' or 'framework' accept), so the semantics remain somewhat shallow beyond the parameter names.

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: 'Search frontend knowledge chunks.' It further distinguishes the tool by detailing its retrieval mechanisms (BM25, hybrid pgvector) and return values (scores, citations, provenance), which sets it apart from sibling tools like find_components or discover_frontend_resources.

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

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

The description provides clear context on how to use the tool: 'Pass query plus optional filters (kind, framework, tags, source_id), limit, and detail_level.' However, it does not explicitly state when to use this tool versus the alternatives, nor does it mention any exclusions or alternative tool recommendations. Usage guidance is implied but not explicitly differentiated.

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