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

Annotations already provide readOnlyHint, idempotentHint, openWorldHint. Description adds behavioral context: uses axe-core engine, checks contrast ratios, calculates accessibility score (0-100), and detects violations with severity classification. No contradictions. Adds value beyond 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?

Single paragraph, front-loaded with the primary purpose. No wasted words, but could be more structured (e.g., bullet points) to improve scanability.

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 no output schema, the description adequately explains the return values (violations, severity, score, contrast ratios). The 5 parameters are well-documented in the schema. Description is sufficiently complete for an agent to understand usage and outcomes.

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. Description adds context about scoring and contrast ratio checking but does not significantly enhance parameter understanding beyond the schema's descriptions and constraints.

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

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

Description clearly states a specific verb and resource: 'WCAG 2.1 accessibility audit using axe-core' with contrast ratio checking. It enumerates specific outputs (violations, severity, score, contrast ratios) and distinguishes from siblings like 'audit.query' and 'quality.evaluate' by being highly specific.

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?

Description implies use for accessibility audit but does not provide explicit guidance on when to use this tool versus alternatives (e.g., audit.query or quality.evaluate). No when-not-to-use or alternative suggestions are given.

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

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

Annotations already declare readOnlyHint and idempotentHint, so the safety profile is clear. The description adds GDPR context but does not disclose other behaviors like pagination or rate limits. Given annotations, the description provides adequate additional 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 extremely concise (two sentences) and front-loaded with the purpose in both Japanese and English. Every sentence adds value with no waste.

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 is a query with 5 parameters, no output schema, and annotations covering safety, the description is minimally adequate but lacks details on return format or usage examples. It could be more complete for a query tool without 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?

All parameters have descriptions in the input schema (100% coverage), so the schema already explains parameter meaning. The description does not add extra value beyond what the schema provides, so baseline 3 is appropriate.

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

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

The description clearly identifies the tool as querying audit logs and references GDPR Art.30, which is specific. However, it does not strongly differentiate from sibling tools like search.unified, but the audit log domain is distinct enough.

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 provided on when to use this tool versus alternatives such as search.unified or data.delete. There is no mention of prerequisites or applicability.

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 indicate readOnlyHint=true and idempotentHint=true, which the description does not contradict. The description adds context about semantic search and filter capabilities, reinforcing the non-destructive, read-only nature. No behavioral traits are missing.

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-loading the core purpose. Every sentence adds value: first states the action, second explains filtering capability. No unnecessary 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?

With full schema coverage and annotations, the description completes the picture for a search tool. It lacks mention of result format or pagination, but these are typical for search and can be inferred from the schema's limit/offset parameters.

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?

Input schema has 100% description coverage, so each parameter is already well-documented. The description only mentions query and two filter fields, adding minimal extra meaning. 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 it performs semantic search for background designs, specifying types like gradients, glassmorphism, and SVG backgrounds. It distinguishes from siblings such as design.search_by_image and layout.search by focusing on background design 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 usage for natural language search of background designs and mentions filtering, but does not explicitly state when to use this tool versus alternatives like design.search_by_image or search.facets. No exclusion criteria or comparisons are provided.

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

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

The description adds substantial behavior beyond the annotations: permanent/hard deletion, CASCADE DELETE for pages, bulk deletion for all_user_data, mandatory confirm: true, and removal of embedding-backfill queue jobs to prevent deleted data from being resurrected. These are critical side effects and safety constraints for a destructive operation.

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 content is front-loaded and logically organized, starting with legal basis and target selection. However, the Japanese and English text duplicate the same information almost exactly, which adds token cost without adding semantic value for an agent.

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 destructive tool with no output schema, the description covers the essential behavior: permanence, target scope, confirm requirement, and asynchronous queue cleanup. It does not mention required permissions, failure behavior, or audit logging beyond the reason parameter, but it is sufficiently complete 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 coverage is 100%, so the schema already documents all five parameters in detail. The description still adds useful parameter-linked behavior: target-specific deletion modes, the confirm requirement, and the queue-job cleanup that applies specifically to page and all_user_data targets.

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: permanent deletion of data under GDPR Art.17 / CCPA §1798.105. It clearly enumerates the three deletion targets (page, profile, all_user_data) and their scope, letting an agent distinguish this from siblings like preference.reset or data.export.

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?

It gives clear context for when this tool applies: legally mandated erasure, with target selection and a mandatory confirm flag. It does not explicitly name alternative tools or when-not-to-use cases, but the legal-erasure context and target scoping are sufficiently clear for correct invocation.

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 provide readOnlyHint=true and idempotentHint=true, indicating safe behavior. Description adds valuable context: exports 'all related data', JSON format, and PII marking. Does not contradict annotations. Could be more specific about scope limits or 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?

Description is succinct, starting with the core purpose (GDPR export), then details (target, format, PII). Two languages but no wasted sentences. Every part adds value and is 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 tool simplicity (2 params, no output schema) and rich annotations, description covers export purpose, target, format, and PII marking. Missing details like return behavior (file vs stream) or error scenarios, but overall adequate for a compliance tool.

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

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

Schema coverage is 100% with descriptions for both parameters. Description adds context by expanding on enum values for 'target' (e.g., 'page (web page + all related data)') and explaining UUID format, enriching beyond schema alone.

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

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

Description clearly states tool exports data under GDPR Art.20 for data portability, specifying targets (page/profile), format (JSON), and PII marking. This distinctively separates it from sibling tools like data.delete (deletion) and audit.query (querying), establishing a unique purpose.

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 links tool usage to GDPR Art.20 right to data portability, giving clear context for when to use. However, does not explicitly state when not to use or mention alternative tools for general data retrieval, leaving some inference 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?

Annotations already declare readOnly/idempotent/closed-world, so safety is covered; the description adds the output contract (pairwise scores normalized 0-1) and what include_details unlocks (common patterns and key differences). It does not mention cost/latency for a 2-5 page pairwise comparison, which is the main residual unknown.

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?

Each language block is two tight sentences, front-loaded with the action and scope, then the return value, then the optional flag. The bilingual duplication doubles the token footprint but is a consistent structural convention rather than 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 no output schema, the description carries the burden of explaining returns and does so (pairwise similarity scores, optional detail block). Minor gap: it doesn't indicate output shape for N pages (e.g. number of pairs) or whether scores are per-dimension, which an agent assembling a report would want.

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 defines page_ids, dimensions, and include_details including defaults and bounds. The description restates the 2-5 range and clarifies that details mean common patterns and differences, but adds little beyond the existing field 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?

Names a specific verb (compare) and a tightly scoped resource (2-5 web pages), plus the four comparison axes and the return (pairwise similarity 0-1). The 'web page' scope distinguishes it from siblings like part.compare, style.get_palette, or design.similar_site without needing the schemas.

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

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

Clearly signals the use case (multi-page comparison across layout/visual/quality/color) and tells the agent how to get extra output via include_details. It stops short of stating when NOT to use it or naming an alternative such as part.compare or quality.evaluate for single-page scoring.

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 establish readOnly/idempotent/closed-world, so safety is covered. The description then adds genuinely useful behavioral context beyond that: DINOv2 visual embeddings, HNSW nearest-neighbor retrieval, and the exact RRF fusion weighting (40/30/30) when a query is present, which tells the agent how results are ranked and why hybrid results may differ.

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?

Four sentences, well front-loaded: purpose first, accepted inputs second, mechanism third, optional-mode fourth. No filler. Slightly over-indexed on implementation internals (DINOv2/HNSW) that an agent does not strictly need to call it.

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?

Parameters are fully documented via schema and safety via annotations, but there is no output schema and the description says nothing about what a result looks like (sections, similarity scores, ordering, count). For a search tool whose output shape is undefined elsewhere, that is a notable remaining gap.

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

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

Schema coverage is 100%, so the baseline is 3; the description earns extra credit by explaining the semantic effect of the 'query' parameter (it switches the whole search into a 3-source RRF fusion rather than a pure visual lookup), which the schema text alone does not convey.

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

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

States a specific verb and resource: searching design sections visually similar to a supplied image. It distinguishes itself from the other *search* siblings (layout.search, motion.search, narrative.search, background.search) by naming the modality (image) and the target resource (design sections) rather than sites or parts.

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?

Explains the two input modes (Base64 or HTTPS URL) and, critically, the condition that switches behavior: an optional text query triggers the RRF hybrid search. That is clear context for mode selection. It stops short of stating when to prefer design.similar_site or search.unified instead, so no explicit 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 provide readOnlyHint and idempotentHint. The description adds rich context: embedding methods (DINOv2 vision, e5-base text), mean pooling, pgvector HNSW search, and RRF fusion with percentages, far exceeding annotation coverage.

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 bilingual and includes detailed technical steps, but it is well-structured with purpose first. Slightly verbose but still clear.

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

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

The description thoroughly explains the search methodology and parameter constraints. However, it lacks explicit description of the return format or ranking, which would be helpful given no 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?

Schema coverage is 100%, but description adds crucial constraints: 'url must exist in web_pages' and explains 'include_details' as common patterns/differences, adding value beyond 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 verb 'search' and the resource 'similar website designs'. It differentiates from sibling tools like 'design.search_by_image' by specifying URL input and embedding technique.

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 parameter description for 'url' specifies it must exist in DB, but there is no explicit when-to-use or alternatives compared to siblings. Usage guidance is minimal.

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 provide idempotentHint=true, and the description aligns with that. However, the description does not add additional behavioral context such as whether code is persisted or just returned, authentication needs, or side effects. 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?

Single paragraph, front-loaded with purpose, no extraneous words. Every sentence adds value. Efficient and clear.

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

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

The description covers the main purpose and parameters. However, it omits the output format (no output schema) and does not explain how to obtain patternId (referring to sibling tools). Given schema richness and nested complexity, more context would improve completeness, but it's adequate.

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 baseline is 3. The description restates some parameter options (framework, typescript, tailwind) but adds no new meaning beyond the schema. Nested options and their interrelations are not elaborated.

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 ('generate code'), the input ('section patterns' via patternId), and the output frameworks (React, Vue, etc.). It uniquely positions the tool among siblings by focusing on code generation, not ingestion or inspection.

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 implicitly indicates usage for generating code from patterns, but it lacks explicit guidance on when to use this tool versus alternatives (e.g., layout.search for finding patterns). No 'when not to use' or context for selection among siblings.

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

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

Annotations already declare readOnlyHint=false, openWorldHint=true, and idempotentHint=false, so the description's real contribution is safety behavior: SSRF protection blocking private IPs/metadata services and HTML sanitization. That is genuinely useful pre-call context an agent cannot infer from annotations or schema. It stops short of disclosing side effects such as database persistence (save_to_db), browser process behavior, or latency/timeout cost on heavy JS sites.

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

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

Three short, front-loaded sentences with zero filler: what it fetches, the security constraint, and a data-handling note. Nothing is redundant or buried.

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 complex (nested options object with browser, screenshot, CSS-fetching, and DB-persistence controls, and a save_to_db -> motion.detect linkage), and the description covers only purpose plus security posture. It omits the DB-first versus response-returning workflow distinction and the fact that ingestion can persist artifacts, which are the main ways an agent could misconfigure this call.

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% and the 25+ nested options are individually documented with ranges, defaults, and enums, so the schema carries parameter semantics. The description adds no parameter-level meaning beyond noting that returned HTML is sanitized and that fetching may yield a screenshot. Baseline 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?

States a concrete verb and resource ('Fetch HTML/screenshot from URL') plus the downstream intent ('for layout analysis'), so the agent knows this is an ingestion step, not an analysis step. It does not distinguish itself from sibling ingestion/analysis tools like layout.inspect, layout.batch_ingest, or responsive.capture, so sibling differentiation is missing.

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

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

There is no explicit when-to-use, when-not-to-use, or alternative routing; nothing says whether this precedes layout.inspect, when responsive.capture is preferable, or when to enable save_to_db versus the DB-first workflow. The only implied guidance comes from the phrase 'for layout analysis' and does not resolve any choice between siblings.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true. Description adds no further behavioral details beyond what's in the schema options, missing opportunities to explain output structure or side effects.

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

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

Single sentence with front-loaded verb and clear object. No unnecessary words, highly efficient.

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

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

No output schema provided. Description covers the main extraction types but does not specify return format or additional behaviors. Adequate but could be more 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% with detailed parameter descriptions. The description does not add new meaning beyond the schema, so 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?

Description clearly states the tool's verb ('Parse HTML and extract section structure, grid, typography info') and resource. It distinguishes from siblings like layout.ingest or layout.search by focusing on inspection.

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

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

No explicit guidance on when to use this tool versus alternatives like layout.ingest or layout.search. Context is implied but not elaborated.

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, idempotentHint, and openWorldHint=false, so the safety profile is clear. The description adds useful behavioral context about search modes and hybrid RRF weighting, but it does not describe return format, pagination, rate limits, or authentication needs. With annotations covering the core safety aspects, this is an adequate but not rich disclosure.

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 four sentences, front-loaded with the core purpose and followed by key capabilities. It is efficient and avoids unnecessary repetition, though it could be slightly better structured (e.g., separating filters from search modes).

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

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

For a tool with 16 parameters, nested objects, and no output schema, the description covers only a fraction of the functionality. It highlights section type filtering and vision search but omits significant features like tags/audience/industry filters, project context, auto-detect context, and preview options. The rich schema compensates somewhat, but the description is not complete enough for the tool's complexity.

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

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

Schema description coverage is 100%, so the baseline is 3. The description mentions some parameters (section type filter, use_vision_search, hybrid weights) but adds little beyond what the schema already documents in detail. It does not clarify the many other parameters like profile_id, project_context, or auto_detect_context.

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 (semantic search) and resource (section patterns), and mentions key capabilities like Japanese/English support, section type filtering, and vision search. It is clear what the tool does, but it does not explicitly differentiate itself from the many sibling search tools (e.g., search.unified, part.search, design.search_by_image).

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 lists capabilities but provides no guidance on when to use this tool versus alternatives. There are no exclusions, no named alternatives, and no conditions that would select this tool over the many other search tools available. The agent is left to infer usage from the purpose 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?

Annotations already declare readOnly and idempotent, but description is misleading by only mentioning CSS parsing, while tool supports multiple detection modes (video, runtime, hybrid) and has network dependencies. Missing crucial behavioral traits like graceful degradation on timeout, dependency on Playwright for JS animation detection, and requirement for baseUrl when fetching external CSS. Description does not add value beyond annotations; it contradicts the full scope of the tool.

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

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

Two sentences, very concise and front-loaded with main purpose. However, it sacrifices necessary detail for extreme brevity, missing critical behavioral context. Still, structure is efficient.

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

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

Given tool complexity (19 params, multiple modes, no output schema), description is insufficient. Does not explain detection modes, required inputs (url vs html vs pageId), return format (list of patterns? warnings?), or side effects like saving to DB (save_to_db param). Agent cannot fully understand tool without reading all parameter descriptions.

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 baseline is 3. Description adds no parameter-level meaning beyond 'CSS animations, transitions, keyframes' which only hints at detection_mode. Does not help agent understand parameter relationships or required inputs for different modes.

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

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

Description states 'Detect/classify motion patterns from web page' with specific mention of CSS animations, transitions, keyframes, and warnings. Clearly identifies the action and resource, but does not explicitly distinguish from sibling tools like motion.search, which is implied by different verb.

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 on when to use this tool vs alternatives. Does not mention prerequisites, such as requiring a pageId or URL depending on detection_mode, nor any conditions for using different modes. Agent lacks context for appropriate invocation.

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 provide readOnlyHint=true, idempotentHint=true, and openWorldHint=false, covering the safety profile. The description adds that generate produces code, but does not mention rate limits, auth needs, or side effects beyond what annotations imply. 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?

Two sentences, front-loaded with the core purpose and action distinctions. Every sentence earns its place with no redundancy.

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

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

Given the rich schema, annotations, and lack of output schema, the description provides enough context for an agent to choose between search and generate. It could explicitly note that generate requires the `pattern` parameter, but the schema covers that requirement.

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 all 15 parameters are fully documented in the schema. The description adds no parameter-specific semantics beyond naming the actions, which is baseline for high schema 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 clearly states two specific actions: similarity search for motion patterns and generation of implementation code. It distinguishes the actions with their names and defaults, but does not differentiate this tool from siblings like motion.detect or layout.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?

It explains when to use each action (search vs generate) but gives no guidance on when to use this tool versus alternative search or generation tools. 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?

Annotations already indicate readOnlyHint and idempotentHint, so core safety is covered. Description adds value by explaining search modes (hybrid, RRF) but does not disclose return format or pagination behavior. 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?

Two concise sentences in Japanese, front-loading the purpose. No extraneous information, though could benefit from more structured 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?

Given 5 parameters, no output schema, and moderate complexity (hybrid search, filters, reranking), the description provides a good overview but lacks details on filters, profile_id, result structure, and pagination. Adequate 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?

Schema has 60% description coverage (moderate), but the description does not add significant meaning beyond schema. It mentions query/embedding and hybrid search, but filters and options are not further explained. Baseline 3 given schema 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?

Description clearly states it performs semantic search on worldview/layout composition using natural language or embeddings, with hybrid search. Implicitly differentiates from siblings like layout.search or part.search by focusing on worldview, but does not explicitly name alternatives.

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 on when to use this tool vs siblings (e.g., background.search, search.unified) or when to choose query vs embedding. Does not specify prerequisites or typical use cases.

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

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

Annotations already declare readOnlyHint, openWorldHint and idempotentHint, and the description usefully adds that execution is parallel and that progress is streamed via _meta.progressToken. It omits material behaviors the agent would want: default persistence to the database (saveToDb defaults true in most sub-options), Vision LLM cost/latency, and the async job handoff to page.getJobStatus.

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

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

Three sentences, front-loaded with the verb and resource, then composition, then the streaming detail. No filler and no restatement of the name.

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

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

For a 27-parameter orchestrator with deeply nested options and no output schema, the description is thin: it does not characterize the unified result shape, the async job lifecycle, or the default-on DB writes and Quick-vs-full summary mode. It covers the headline purpose but not enough of the operational surface for a tool this complex.

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% across 27 parameters, so the schema carries the parameter burden and the baseline is 3. The description adds nothing about parameter semantics apart from mentioning _meta.progressToken, which is not even an input property.

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

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

States a specific verb (analyze) and resource (web page URL) plus the three concrete analyses performed (layout detection, motion extraction, quality evaluation). It also names the exact sibling tools it composes (layout.ingest, motion.detect, quality.evaluate), making the orchestrator-vs-single-phase distinction explicit.

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?

By saying it runs the three sibling tools in parallel and returns unified results, it implicitly tells the agent to use it when all phases are wanted and to use the individual tools otherwise; the features flags reinforce that phases can be selectively disabled. It stops short of an explicit 'do not use this if you only need layout' exclusion.

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 annotations (readOnlyHint=false, openWorldHint=true), the description discloses async/non-blocking behavior, the 50-URL cap, concurrency bounds, SSRF pre-validation, per-URL failure isolation, and a 10 RPM tier rate limit. These are exactly the operational facts an agent needs to avoid mis-calling an async batch 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 lead sentence front-loads the core behavior and the bullets are scannable. There is mild redundancy: progress tracking via page.getJobStatus appears both as a bullet and as a closing sentence, and 'BullMQ' is an implementation detail that does not help tool selection.

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 7-parameter tool with nested objects and no output schema, the description covers the important contract: it returns immediately with a batch ID and results are retrieved via page.getJobStatus. It does not describe what the polled result payload contains or whether partial results are visible mid-batch, which is the main remaining gap.

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

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

Schema description coverage is 100%, so every parameter is already documented, and the description mostly restates schema facts (concurrency 1-5 default 3, 50-URL cap). It does add a little meaning by tying 'graceful degradation' to the on_error='skip' behavior and by noting SSRF validation applies to the urls array, but timeout, features, and layoutOptions get no added explanation.

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 with scope: batch-analyze multiple URLs in parallel, submitted as async jobs, returning a batch ID immediately. That clearly separates it from the single-URL sibling page.analyze, though it never names page.analyze as the alternative, so the differentiation is inferred rather than explicit.

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?

It gives a clear usage path: submit up to 50 URLs, then poll page.getJobStatus with the returned batch_id for results. What is missing is an explicit exclusion rule such as 'for a single URL use page.analyze instead', which would make routing unambiguous among 27 siblings.

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

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

Beyond the readOnly/idempotent/closed-world annotations, the description discloses the Redis dependency, the 24-hour job and 48-hour batch retention windows, the full set of possible states for each path, and what each return shape contains. This is exactly the kind of operational context annotations cannot convey.

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 purpose is front-loaded in one line, then two clearly labeled blocks separate the job_id path from the batch_id path, each with a bulleted return summary. No sentence is redundant, and the mutual-exclusion constraint is stated before the return details.

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

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

With no output schema, the description carries the return-value burden itself and does so thoroughly for both modes, including state enumerations and batch summary counts. The Redis prerequisite and retention limits round out everything an agent needs to call and interpret this 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?

Schema coverage is already 100%, so the baseline is 3, but the description adds value by tying each parameter to the specific sibling tool that produces it and reiterating the mutual-exclusion rule. It stops short of explaining behavior for malformed or expired IDs, which would have pushed it higher.

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 first sentence names a specific verb ("Check the status") and two concrete resources ("async page analysis job" and "batch"), which cleanly separates it from page.analyze and page.batch_analyze, the tools that create those jobs. An agent can identify the tool's role without inspecting the schema.

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

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

It explicitly routes usage: pass exactly one of job_id (from page.analyze with async=true) or batch_id (from page.batch_analyze), which tells the agent where each ID originates and that they are mutually exclusive. It lacks an explicit "when not to use" statement or guidance on polling cadence, keeping it just below the top mark.

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, idempotentHint and openWorldHint=false, so the safety profile is covered by structured data. The description adds that comparison is property-level identity-aware and defaults to two aspects, but says nothing about error behavior for invalid/unknown part IDs or what a mismatch 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?

Front-loaded with the operation and cardinality, then aspects and defaults — no wasted clauses. The Japanese/English mirroring doubles the length, but that appears to be an intentional convention across this toolset rather than 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?

There is no output schema, so the description carries the burden of explaining results, and 'Reports property-level identity' is only a thin hint at the response shape. For a read-only two-parameter tool this is workable but leaves an agent guessing what the comparison output contains.

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

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

Schema coverage is 100% and both parameters carry their own descriptions, including the minItems/maxItems and enum constraints, so the schema does the heavy lifting. The description restates the 2-5 range and the styles+layout default, adding no syntax or semantics 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?

States a specific verb and resource ('compare 2-5 UI parts') and enumerates the four comparison aspects plus the default subset, so the operation is unambiguous. It does not differentiate itself from the sibling design.compare, which is the one plausible confusion an agent could have.

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 default aspects (styles + layout) imply the typical use case, but there is no explicit statement of when to pick this over design.compare or when to inspect parts with part.inspect first. Usage is inferable 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?

Annotations already declare readOnlyHint and idempotentHint. The description adds value by listing specific return fields (styles, HTML, bounding box, etc.), which supplements the annotation's safety profile.

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, bilingual, and front-loaded with the action. Every word is necessary and no 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 no output schema, the description adequately lists return fields. Parameter coverage is complete. However, it could briefly mention the required part_id, but the schema already handles that.

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% and provides clear parameter descriptions (part_id as UUID, include_html/embedding as booleans with defaults). The tool description does not add extra semantic meaning beyond what the schema already conveys.

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 inspects a UI component part by ID and lists the returned information (styles, HTML, bounding box, etc.). It differentiates from siblings like part.compare and part.search by focusing on inspection.

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 this is for getting detailed info on a single part, but lacks explicit guidance on when to use versus alternatives like part.compare or part.search. No exclusion criteria 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?

Annotations already indicate readOnly and idempotent. The description adds details about the search models (e5-base, full-text) and future support for image search, but does not disclose additional behavioral traits beyond what annotations provide.

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 front-loaded with key information. However, it includes bilingual content that could be streamlined for brevity, but overall it is efficient.

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

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

Given the complexity (11 parameters, no output schema), the description covers the purpose and main filters but does not explain the return format, pagination, or edge cases. Annotations help but the description could be more 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?

Input schema description coverage is 100%, so the description adds no extra meaning beyond parameter names and types. It mentions partType and searchMode but these are already in 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 performs semantic search of UI component parts with hybrid search, and lists filtering options. It distinguishes from sibling tools by focusing on UI parts, but does not explicitly differentiate from other search 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 lacks guidance on when to use this tool vs alternatives. It does not mention when not to use it or provide context for choosing it over other search tools on the server.

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, idempotentHint, and openWorldHint. The description adds context that it uses Playwright PerformanceObserver, returns a score/grade/recommendations, and mentions optional improvement recommendations, which complements the annotations without contradiction.

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: first defines purpose and method, second describes output. Every word is essential, no redundancy. Perfectly front-loaded.

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

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

Given no output schema, the description covers return format (score, grade, recommendations). It explains the evaluation metrics and optional details. Could mention error handling or limitations, but sufficient for the complexity of a performance evaluation tool.

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

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

Schema description coverage is 100%, so the description adds value by explaining the tool's purpose and output format (score 0-100, grade, recommendations), which helps agents understand what parameters like include_details affect. The description enriches the semantics beyond the schema's field-level 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 specifies the tool evaluates web page performance using Core Web Vitals (LCP, FID, CLS, INP, TTFB) via Playwright PerformanceObserver API, and returns a score, grade, and recommendations. This clearly distinguishes it from siblings like accessibility.audit or quality.evaluate.

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 this tool is for performance evaluation but does not provide explicit guidance on when to use it versus other sibling tools like quality.evaluate or page.analyze. No when-not-to-use or alternative suggestions are given.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and openWorldHint=false, so safety is covered. The description adds only that cliche detection exists and that three axes are scored, but does not disclose the cost/behavioral implications of heavy options such as use_playwright runtime testing, responsive_evaluation network fetches, or the summary vs full-detail mode, which materially change what the agent receives.

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 tightly written sentence with the core capability front-loaded and zero filler. Nothing is redundant, though the brevity is also the source of the definition's gaps elsewhere.

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 12-parameter tool with nested objects, browser-based responsive evaluation, Playwright aXe testing, and no output schema, one sentence is far too thin. The agent gets no sense of the report shape (scores, recommendations, cliche patterns, accessibility violations) or the trade-offs between lightweight summary mode and full detail.

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 all 12 parameters including nested weights, context, and responsive_evaluation are already documented in the schema. The description's mention of the three axes lightly frames the weights object but adds no syntax or interaction detail beyond that, so the baseline 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 names a specific verb (evaluate) and resource (web design quality), and enumerates the three scoring axes plus AI cliche detection. This distinguishes it reasonably from siblings like performance.evaluate and accessibility.audit, though it never explicitly contrasts itself with design.compare or design.regression_test.

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

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

There is no guidance on when to invoke this tool, when to use an alternative, or what prerequisites exist. Notably, the tool accepts either raw HTML or a pageId and the description says nothing about which to supply or what happens if neither is given, leaving the agent to infer invocation conditions from the 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?

Annotations already declare readOnlyHint and idempotentHint. The description adds behavioral details: default viewports, detection of section visibility, font size changes, grid columns, spacing, and a diff score (0-100). No contradiction.

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 action and then specifics. No filler words, efficient for an agent 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?

The description covers tool purpose, default behavior, output score, and detection items. Lacks exact output structure (e.g., JSON format) but sufficient for most agents. Given no output schema, it provides enough 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% with parameter descriptions. The description adds value by explaining default viewports and the analysis details (diff score, detection items) beyond schema, especially for 'include_diff' and 'url' context.

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 captures a web page at three viewports and analyzes responsive layout differences, with specific detection items and a diff score. This distinguishes it from siblings like 'responsive.search' which likely searches in captures.

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 analyzing responsive design differences but does not explicitly state when to use or avoid this tool, nor mention alternatives like 'design.compare'.

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. The description adds behavioral context about filtering by various attributes (categories, viewport pairs, etc.), which is valuable 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?

Two concise, front-loaded sentences that cover the tool's purpose and filtering options without redundancy. Every sentence adds value.

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 with no output schema, the description explains the search domain and available filters but does not hint at the result format (e.g., structured data). Still, it is fairly complete given the complexity.

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 100% schema coverage, the schema already documents all parameters. The description mentions filtering capabilities but does not add significant meaning beyond what the schema provides. 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 it performs semantic search on responsive design analysis results, specifically for differences between viewports. It distinguishes itself from sibling tools like layout.search or design.compare by focusing on responsive differences.

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?

While the description implies when to use (search for responsive differences), it does not explicitly mention when not to use or provide alternatives. However, the context from sibling tool names and the specific focus makes usage fairly clear.

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 safety (readOnly, idempotent, closed-world), so the description's added value is the execution model: parallel sub-searches plus similarity-ordered merging, which tells the agent the results are aggregated rather than from a single index. It does not disclose failure handling if one sub-search fails, latency/cost expectations, or the shape of each merged result, keeping it below a 5.

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

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

Two compact sentences that front-load the scope and then the mechanism; nothing is wasted. The Japanese/English duplication roughly doubles length, but that is a consistent localization pattern rather than padding, and each language version is tight.

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 12 parameters and no output schema, the description carries some burden for describing what comes back, and it only says results are merged and sorted by similarity — it never mentions per-type fields, whether facet counts come back alongside hits, or what happens when `include_facets` is set. Adequate to select and invoke the tool, but thin on response expectations for a fairly rich search surface.

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 every one of the 12 parameters is already documented in the schema, including enums, defaults, and the implicit include_facets behavior. The description adds no parameter-level meaning (e.g., how `query_type` interacts with `enable_reranking`, or what `profile_id` reranking does), so the baseline 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?

States a specific verb (cross-component semantic search) and enumerates the five resource domains it spans (Layout, Part, Motion, Background, Narrative). It also explains the mechanism — running the individual search tools in parallel and merging by similarity — which lets an agent distinguish it from siblings like layout.search, part.search, and motion.search without opening their schemas.

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

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

The description makes clear this is the cross-cutting option that fans out to the individual search tools, implicitly contrasting with the single-domain siblings, and the `types` parameter signals it can also be narrowed. It stops short of an explicit 'use X instead when you only need one component type' rule or any guidance on when the extra cost of a parallel fan-out is warranted.

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. The description adds valuable behavioral context by detailing exactly which health components are checked (metrics, cache, initialization, pattern services, etc.), which goes beyond the annotations. No contradictions.

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

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

The description is two sentences, front-loaded with the action, and lists the checks concisely without any redundant or extraneous information. Every sentence adds value with zero waste.

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 explains what the tool checks and mentions 'returns diagnostics' but does not specify the return format (e.g., JSON structure). Since there is no output schema, some guidance on the response structure would be beneficial, but the description is sufficient for understanding the tool's purpose. The seven optional parameters are well-covered in the 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?

Schema description coverage is 100% with each parameter having a clear description and defaults. The description provides a high-level grouping of parameters into categories (metrics, cache stats, etc.), which adds some context but does not significantly enhance what the schema already provides for individual 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 runs a health check on the MCP server, listing specific components checked (metrics, cache stats, initialization, pattern services). It uses a specific verb-resource combination ('Run MCP server health check') and distinguishes from sibling tools that focus on specific functionalities like accessibility, design, or 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?

No explicit guidance is provided on when to use this tool versus alternatives. There is no mention of when not to use it or which scenarios it is best suited for. The description only states what it does, leaving the agent to infer usage context.

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