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

With no annotations, the description carries the burden and does well: it declares the operation read-only and bounds scope (no form submissions, no remote browsing). It doesn't say where results land or how report overwriting behaves, but the safety profile is clearly disclosed.

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

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

A single dense sentence, front-loaded with the read-only audit framing before the defect list and exclusions. The defect enumeration is long but each item is informative, with minimal 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?

For a 6-parameter tool with no output schema, the description covers operation, safety scope, and viewport behavior adequately; destination and overwrite details are delegated to the schema's reportPath/overwrite descriptions. Missing only explicit guidance on prerequisites (a running local server) and result format.

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

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

Schema coverage is 83%, so the schema already documents url, overwrite, reportPath, projectRoot, and viewports well. The description only echoes 'at multiple viewports' and adds nothing about the URL/port constraint or timeout semantics beyond the schema, so 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?

Specific verb+resource ('Read-only audit of localhost web UI') with an enumerated set of detected defects (overflow, offscreen elements, broken images, unlabeled controls, etc.). It clearly differs from siblings like review_ui, inspect_ui_project, and capture_ui_screenshots by being an automated defect-detection audit.

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 establishes the setting ('localhost web UI using project Playwright') and two exclusions ('no form actions or remote browsing'), which implies when it fits. However, it never names an alternative tool or states when to prefer review_ui or capture_ui_screenshots, so routing is left to inference.

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

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

With no annotations provided, the description carries the full behavioral burden and usefully discloses that calls are forwarded to an explicitly allowed downstream MCP, that output is returned as original text/image/tool output, and that calls may change files or other state. It does not cover failure behavior, timeouts, or auth propagation, but it covers the key mutation and trust constraints.

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 tight sentences: purpose first, then prerequisite discovery, then safety warning. Every sentence earns its place and nothing is 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?

For a bridge tool with no annotations and no output schema, the description supplies the essential discovery path, return behavior, and mutation warning. It remains silent on error handling and downstream auth behavior, but it is complete enough for an agent to select and call the tool correctly.

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

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

Schema description coverage is 100%, so the schema already documents server, tool, and arguments. The description adds the allowlist/trust framing and points to bridge_list for tool names and schemas, but it does not add syntax or deeper parameter 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?

The description states a specific action, 'Forward a tool call,' and a specific resource, an explicitly allowed downstream MCP, with clear return types. It also distinguishes itself from the sibling bridge_list by assigning discovery to that tool rather than to bridge_call.

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

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

It explicitly directs the agent to use bridge_list with connect:true to obtain available tool names and schemas before calling. It also warns that calls may change files or other state and advises configuring only trusted commands and allowlisting necessary tools.

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

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

With no annotations, the description does useful work: it discloses that downstream servers run under the user's local permissions, that a specific config file is required, and that connect=true starts downstream servers while the default only lists configurations. It stops short of covering error behavior or permission prompts.

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 main action, and no wasted text. The optional connect behavior and prerequisite are stated compactly.

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

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

For a two-parameter tool with no output schema and no annotations, the description covers the key operational context: config prerequisite, local permission scope, and the difference between listing and connecting. Return shape is only briefly indicated.

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

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

Schema description coverage is 100%, so both parameters are already documented. The description reinforces the connect parameter's behavior but adds little beyond the schema for the server parameter.

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: 'List explicitly configured downstream MCPs'. It also clarifies the optional discovery behavior, though it does not explicitly name or contrast the sibling bridge_call tool.

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 what connect=true does and notes that a .awsm/bridges.json config is required, but it gives no explicit when-to-use guidance versus bridge_call or other bridge-related tools. Usage is implied rather than directed.

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

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

With no annotations, the description carries the full burden and does well: it discloses reduced motion, isolated contexts, blocked outbound network, console error collection, and the important limitation that browsers are not auto-installed. What is missing is the mutation profile — that screenshots are written to disk and may overwrite existing files (only visible via the schema), and nothing about runtime cost or failure modes.

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

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

Two sentences, front-loaded with the action and engine, followed by the behavioral guarantees and the key limitation. No filler, and the most decision-relevant constraint (no browser install) is placed last for emphasis.

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 no output schema and no annotations, the description covers the environment, safety posture, and prerequisite well. The main gap is return semantics — it says a 'console error inventory' is produced but not whether/how it is returned or where screenshot paths surface in the response.

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 86%, so the schema already documents nearly every parameter including defaults and bounds. The description reinforces 'mobile and desktop' (the viewport defaults) and the localhost/Playwright-install prerequisites, but adds no syntax, units, or semantics beyond what the schema states.

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 gives a specific verb ('capture') plus resource ('mobile and desktop localhost screenshots') and names the underlying engine (Playwright in the target project). It clearly separates this from pure analysis siblings like audit_ui_page, though it never explicitly names compare_ui_screenshots as the read/compare alternative.

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?

'Use Playwright installed in the target project' plus 'Does not install browsers automatically' implies the prerequisite (a local dev server and an existing Playwright install) and one exclusion. However, there is no explicit statement of when to choose this over compare_ui_screenshots or audit_ui_page, so routing is left to inference.

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

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

No annotations exist, so the description carries the burden. It does disclose two useful behaviors: only opaque colors are supported (no alpha compositing) and both AA and AAA thresholds are evaluated. However it never says what the caller receives back (raw ratio numbers vs. per-level pass/fail) and does not mention the 100-pair batch ceiling, leaving real gaps for a zero-annotation 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?

A single tight sentence with the core action front-loaded and the largeText hint trailing. No filler, no repetition of the title.

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 annotations, no output schema, and 0% schema coverage, the description should anchor the return shape and the batch limits. It covers the input semantics adequately and the opacity constraint, but an agent still cannot predict the response structure or the 100-pair cap without reading 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 0%, so the description must compensate; it partially does by establishing that foreground/background are hex colors and clarifying that largeText maps to WCAG large-text thresholds. It says nothing about the label field or the min/max item constraints, so roughly half the parameter surface is still undocumented.

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 (evaluate), a specific resource (foreground/background hex color ratios) and the standard being applied (WCAG AA and AAA). No sibling tool in the list shares this domain, so there is no ambiguity to resolve and an agent can select it immediately.

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?

Usage is implied by the purpose statement (you call it when you need to verify color contrast compliance), but there is no explicit when-to-use/when-not-to-use guidance, no prerequisites, and no mention of how it relates to siblings like extract_design_tokens or audit_ui_page. The only directive offered, 'specify largeText for large type,' is parameter-level, not selection-level.

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

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

With no annotations, the description carries the burden well: it discloses that the heatmap write is optional, that it is destructive-safe ('only when explicitly true' via overwrite), and what metrics are returned. It does not explain failure behavior when image dimensions mismatch or what happens when diffPath exists and overwrite is false.

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 pack purpose, output contract, optional side effect, and scope exclusion with no filler. The exclusion clause is placed last where it functions as a disambiguator without burying the primary action.

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 exists, and the description compensates by naming every returned metric, which is the critical gap-filler. For a six-parameter mutation-capable tool with no annotations, error/precondition handling (size mismatch, existing file) is the only notable omission.

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 six parameters are already documented with defaults and ranges; the description reinforces the same ground (diff heatmap, threshold pass/fail, same-size requirement). It adds the semantic framing of the diff output but no parameter detail beyond the schema, so baseline 3 is appropriate.

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

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

States a specific verb and resource ('Compare two same-size PNG screenshots') and enumerates exactly what is produced: diff percentage, mean absolute error, changed bounding box, threshold pass/fail. The closing 'not semantic UX analysis' draws a bright line against siblings like review_ui and audit_ui_page.

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 exclusion of semantic UX analysis implicitly routes pixel-level verification here and judgment-based review to review_ui/audit_ui_page. The 'same-size' precondition is stated, but no explicit when-to-use guidance or reference to capture_ui_screenshots as the upstream step.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses that the tool is a single call, performs 'lightweight' detection, optionally layers in FigCraft data, and trades off audit depth in fast mode. But it does not clarify side effects—whether it writes files, modifies the project, or is purely a planning/read operation—nor does it explain return shape.

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 dense sentences, front-loaded with the core value proposition and followed by the speed trade-off. No filler 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?

For a six-parameter orchestration tool with no annotations and no output schema, the description covers the main capabilities but leaves important gaps: it does not explain what the returned plan contains, whether the call has side effects, or how 'root' changes behavior. Adequate but not complete for a tool of this 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 coverage is 100%, so the baseline is 3. The description reinforces semantics for 'brief', 'speed', and the optional FigCraft inputs, but adds no new format, syntax, or constraint details beyond what the schema already documents.

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 function: a single-call planner that turns a brief into a first-render plan, listing the components it covers (project detection, FigCraft classification, typography, first screen scope, viewport checks). It is clear what the tool does, though it never distinguishes itself from siblings like inspect_ui_project or audit_ui_page.

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 a first-pass tool by noting that 'fast mode postpones exhaustive audits until after a usable preview,' which hints at sequencing relative to deeper audit tools. However, it never names an alternative or explicitly states when to choose this over inspect_ui_project, audit_ui_page, or review_ui.

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

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

With no annotations, the description carries the behavioral burden and discloses several important traits: a 10 MB maximum, no overwriting of existing files, and disabled external SVG downloads. It omits failure behavior, permissions/auth needs, and what is returned (e.g., saved path), but the core safety and constraint profile is unusually well covered for this tool type.

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-loads the action and destination, then adds constraints in short, scannable clauses. Every sentence earns its place; there is no redundant restatement of the title or schema.

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 three-parameter download tool with no output schema, the description covers the critical constraints an agent needs to invoke it correctly. It could be slightly more complete by stating what happens on duplicate/overwrite attempts or what value is returned, but the essentials are present.

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 url, dir, and filename with defaults and sanitization notes. The description adds only the default folder path and URL context, not new parameter semantics; 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?

States a specific verb and resource: save one raster image from a URL to a project folder. The raster-only and URL-source scope distinguishes it from sibling asset tools such as make_asset, find_images, and draw_icon without needing to open 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?

Provides a useful precondition ('Check the source license first') and a clear exclusion ('External SVG downloads are disabled'), but does not name alternatives for SVG handling or explain when to choose this over sibling workflows like make_asset or sync_figcraft_assets. Usage is mostly implied by constraints rather than explicitly routed.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses only that output is 'local' (a filesystem write) and that the caller should verify the rendering; it says nothing about overwrite behavior, whether the SVG is returned or only written, what permission or directory assumptions apply, or how failures surface. For an unannotated file-writing tool this is a significant disclosure gap.

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

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

Two sentences, front-loaded with the core action and artifact, with the disambiguation and verification note packed into the second. 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?

The input schema is rich and self-documenting, and the description covers the essential 'author primitives, not a prompt' mental model. However, with no annotations and no output schema, the agent gets no information on what the tool returns, what the file layout looks like beyond the schema's dir default, or what 'verify the rendered result' concretely entails. Adequate but with clear gaps for a tool that writes to disk.

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 defaults, ranges, the 24x24 coordinate system and the primitive enum are all already documented in structured data. The description's enumeration of primitives merely restates the enum and adds no semantics beyond the schema. 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 and artifact: 'Produce a local custom SVG icon from structured ... primitives'. This clearly separates it from retrieval siblings like find_icons/get_icon by implying net-new creation, though it never names them. The 'Not text-to-image generation' clause sharpens the boundary against a different class of tool, giving an agent enough to select it.

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 one explicit exclusion ('Not text-to-image generation') and one usage instruction ('verify the rendered result'), but never says when to call this versus find_icons, get_icon, or make_asset. The implied rule — use this when you must author an original icon from vector primitives rather than look one up — is left for the agent to infer.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses the extraction scope and that it will not guess semantic color roles, but it does not state whether the operation is read-only, what permissions are needed, how maxNodes affects traversal, or what the response shape 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?

The description is two compact sentences with the core action and scope front-loaded. Every phrase contributes either extracted value categories, output primitives, or an important limitation.

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

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

For a two-parameter extraction tool with no annotations and no output schema, the description gives a useful high-level output description and one key caveat. However, it leaves maxNodes unexplained and does not describe the token-candidate output structure, so it is only minimally 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 description coverage is only 50%: the document parameter is described as a raw FigCraft layer tree rather than a screenshot, but maxNodes has no semantic explanation beyond its numeric bounds. The description itself does not mention either parameter or explain how maxNodes constrains extraction.

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, 'Collect', and names the exact observed design values: colors, font families, weights, sizes, radii, and gaps. It also clarifies the return type at a high level, token candidates and CSS primitives, which makes the tool distinguishable from semantic palette tools, though it does not explicitly name sibling 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 implies the tool is used to extract raw observed values from a FigCraft document, but it gives no explicit when-to-use guidance, prerequisites, or alternatives among siblings such as palette or inspect_ui_project. The only exclusionary note, 'Does not guess semantic color roles', is a limitation rather than routing guidance.

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

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

With no annotations, the description does real work by disclosing capped concurrent provider requests and a short in-process cache, which warns the agent that results may be reused across calls. However, it says nothing about rate limits, failure modes, or what the response contains, leaving a meaningful gap for a no-annotation 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 compact clauses with the core action front-loaded and the discovery-only boundary placed at the end. The phrase "reduce repeated design work" is mildly promotional but still conveys caching behavior.

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 6-parameter tool with no annotations and no output schema, the description omits any indication of return structure (how many results per query, whether images and icons are separated) and does not cover the undocumented parameters. It is adequate to recognize the tool but not fully sufficient to call it confidently.

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

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

Schema coverage is 67%, and the description adds no meaning beyond the schema — it never mentions query count limits, the default provider, or the default icon family. The baseline of 3 applies since the schema documents most parameters, but the description does not compensate for the remaining undocumented ones.

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 combined resource set ("search multiple relevant images and icons in one MCP call"), which implicitly distinguishes it from the single-type siblings find_icons and find_images. It never names those siblings outright, so the differentiation is inferential 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?

"Discovery only; licensing and download remain separate" gives a useful boundary that points an agent toward a download step, but it never states when to pick this tool over find_icons or find_images, nor any prerequisites. Usage is implied rather than prescribed.

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

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

No annotations are provided, so the description carries the burden. It usefully discloses two facts an agent would otherwise have to discover: no API key is required, and results are identifiers plus preview URLs rather than inline SVG markup. It says nothing about result ordering, empty-result behavior, or rate limits, which is a meaningful gap for a search tool with zero 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?

Three short sentences, zero filler. Capability, return contract, and the key usage tip are all front-loaded, and each sentence earns its place.

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

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

With no output schema, the description correctly spends words on return values (family:name identifiers, preview URLs), which is exactly what an agent needs to chain into get_icon. The only shortfall is the missing pointer to that sibling tool and absent guidance on empty results.

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 all three parameters are already documented and the baseline is 3. The description adds meaning beyond that by explaining the intent behind 'prefix' — pin one family (e.g., lucide) for visual consistency rather than mixing families — which is strategy the schema 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 (search for free SVG icons via Iconify) and names the backing source, which distinguishes it from siblings like get_icon or draw_icon. It also previews the return shape (family:name identifiers, preview URLs), though it never explicitly names the alternative retrieval tool.

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 closing sentence gives a real practice tip ('Choose one family... for a consistent UI'), implying this is the discovery step before fetching a single icon. However, it never states when to use this versus get_icon, find_images, or find_design_assets, so the routing decision is left to inference.

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

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

With no annotations, the description carries the burden and does real work: it discloses credential requirements per provider, a licensing caveat ("Verify source licenses before use"), and a semantic warning that picsum results are not subject-matched. It omits return payload shape and any rate-limit or failure 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?

Three tight sentences: the action first, the provider routing second, the licensing caveat last. No filler and nothing buried past the opening clause.

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 five-parameter search tool with no output schema, the description covers provider selection and the main correctness hazard (license/picsum mismatch). The one real gap is that it never indicates what a result contains (image URL, attribution, dimensions), which matters since no output schema exists.

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

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

Schema coverage is 100%, so baseline is 3; the description adds meaning beyond the schema by explaining what each provider enum value implies (keyless vs keyed, commercially usable vs placeholder) and by flagging the license check. It does not restate width/height or limit, which the schema already documents.

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 ("Search for images by query") and immediately enumerates the four providers, which distinguishes it from find_icons and find_design_assets. It never explicitly names those siblings, so differentiation is inferable rather than stated.

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?

Gives concrete selection criteria between providers: openverse is the keyless default with commercially usable CC/PD results, pexels/unsplash require named env keys, and picsum is called out as random placeholders that are not subject-matched. It does not say when to prefer this over find_icons or find_design_assets.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses that the response is SVG markup and implies a read-only retrieval, but it does not address error behavior for unknown icons, authentication, rate limits, or whether markup is a raw string versus wrapped object.

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 definition is a single tight sentence with the retrieval action and identifier format front-loaded. Every clause adds useful context without redundancy.

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

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

For a simple two-parameter retrieval tool with no output schema and full schema coverage, the description is largely complete: it states what is returned (SVG markup) and the intended consumer context (HTML/JSX). It stops short of covering failure modes or return structure, but those are secondary for this tool type.

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

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

Schema description coverage is 100%, so both parameters are already documented in the schema, establishing a baseline of 3. The description reinforces the 'family:name' format with an example ('lucide:rocket'), but does not explain the height parameter or its default beyond what the schema provides.

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

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

The description states a specific verb ('Retrieve') and resource ('SVG markup for one Iconify icon') with an exact identifier format and example. It implicitly contrasts with search-style siblings like find_icons by specifying 'one' icon identified by 'family:name', 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?

The intended use ('for use in HTML or JSX') is stated, which gives context. However, there is no explicit guidance on when to use this instead of find_icons or other asset tools, and no exclusions or prerequisites are mentioned.

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

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

No annotations are provided, so this description carries the full load and does reasonably well: it discloses that install writes local files, that content hashing and signature checking are applied, that an overwrite safeguard exists, and that licensing/glyph coverage are the user's responsibility. It omits return shape and failure behavior, which keeps it below 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 clauses; the read-vs-write distinction is front-loaded and the caveat is placed last as a closing warning. Dense but no wasted sentences.

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 annotations and no output schema, the description should say more about what 'face metadata' actually contains and what happens on a hash/signature mismatch. The safety story is covered, but the inspection result is left opaque.

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?

At 67% schema coverage, the description adds meaning for the install/weights/overwrite path ('selected font weights', 'content hash, signature and overwrite safeguards'). But it never mentions the `style` parameter (an undocumented enum) or the `dir` default, so it doesn't fully compensate for the coverage 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?

States a specific verb+resource ('Fetch Google Fonts CSS2 WOFF2 face metadata') plus the optional mutation ('install selected font weights'). The two modes are clearly distinguished, though nothing separates it from siblings (none of which are font tools, so the cost is low).

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 word 'optionally' implies inspect-by-default and install-on-demand, but the description never states when to pick one mode over the other or any prerequisites (e.g., project must have a public/ dir). The warning 'License and glyph coverage require review' hints at a precondition without spelling it out.

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

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

No annotations are provided, so the description carries the behavioral burden. It usefully discloses that inspection is bounded and avoids recursive scans, which is important context beyond the schema, but it does not explicitly state that the operation is read-only or describe output/side effects.

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

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

The description is a single front-loaded sentence with no wasted words. It is dense but appropriately sized for the tool's scope.

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 two optional parameters, full schema coverage, no annotations, and no output schema, the description covers the inspection scope adequately. However, it does not explain what kind of result is returned or clarify read-only behavior, leaving some contextual gaps.

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

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

Schema description coverage is 100%, so both root and maxEntries are already documented in the schema. The description adds only the general notion of bounded inspection and does not contribute additional parameter semantics.

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

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

The description states a specific operation (bounded filesystem inspection) and explicitly lists what it detects: app framework, reusable components, assets, icon/design packages and scripts. It is clear what the tool does, though it does not distinguish itself from siblings such as find_design_assets or review_ui.

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 shallow, non-recursive scan but gives no explicit when-to-use guidance, prerequisites, or alternatives. An agent must infer that this is a quick initial survey rather than a deeper audit or asset search.

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

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

With no annotations, the description carries the behavioral burden and delivers the two highest-value traits: output is text-based SVG, and long text does not wrap automatically (a real failure mode for callers). It omits file-write behavior such as overwrite semantics and what is returned after generation, leaving a gap for a tool that writes to disk.

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 action and the enumerated asset types, then the two caveats. Nothing superfluous.

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 9-parameter generation tool with full schema coverage but no annotations and no output schema, the description covers the main pitfalls (no auto-wrap, not AI-generated) and pins the primary format. The missing piece is what the tool returns or writes (path, filename confirmation), which the agent would have to discover empirically.

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 nine parameters are already documented by the schema. The description adds only one parameter-adjacent fact — the 1200×630 OG card dimension, which informs width/height defaults — which is a marginal gain over 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 ('Create a text-based SVG template') and enumerates the exact asset types matching the kind enum: og-card, banner, badge, placeholder. An agent can distinguish this from image-fetching siblings like find_images or download_asset without opening 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?

'Not an AI image generator' explicitly rules out the closest wrong-tool assumption, orienting the agent away from image search/generation siblings. However, no positive when-to-use context or named alternatives (e.g., draw_icon, find_images) are given, so it lacks full routing guidance.

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

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

With no annotations, the description carries the burden and does well: it discloses the return format (CSS custom properties) and a genuine caveat that generated colors may fail contrast checks. It stops short of saying whether output is deterministic or how properties are named, but for a pure derivation function that is a minor gap.

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

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

Two tight sentences: capability and scheme options first, return type and caveat second. Nothing is redundant and nothing needs re-reading.

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

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

For a two-parameter, single-output helper with no output schema, the description covers inputs, output medium, and a safety caveat. Only the concrete shape/naming of the emitted CSS variables is unstated, a small omission given the tool's simplicity.

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

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

Schema coverage is already 100%, so the baseline is 3. The description adds real meaning by glossing 'complete' as 'all three plus tint/shade', which the schema only marks as the default; the hex input format is left to the schema, which handles it adequately.

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

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

States a specific verb (derive) and resource (colors) from a hex input, and enumerates the four scheme modes including what 'complete' means. An agent can distinguish this from check_contrast or extract_design_tokens without opening 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?

The phrase 'check contrast before use' gives a useful downstream workflow hint pointing toward the check_contrast sibling, but there is no explicit statement of when to choose palette over extract_design_tokens for existing colors. Usage is implied rather than prescribed.

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

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

With no annotations, the description must carry behavioral disclosure, and it does reveal the deterministic planning behavior and that a manifest may be written. It does not state that this writes files to disk (implied only by the exportDir/overwrite params), nor whether existing files are affected, nor any permission or execution-cost considerations for a filesystem-mutating 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?

Three tight sentences with the classification capability front-loaded and no filler. Slight density cost: 'FigCraft inspect_document' is referenced as a bare tool chain without explanation, but the structure is otherwise 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?

Seven parameters with none required leaves real ambiguity about which inputs are mandatory and whether the document/documentPath and inspectAssets/inspectAssetsPath pairs are mutually exclusive; the description does not clarify this. Since there is no output schema, the description should at least sketch what the export plan/manifest contains, which it does not.

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 parameter meanings are already fully documented in the schema, which sets the baseline at 3. The description's 'raw inspect_document JSON, not a screenshot' restates the document parameter's schema description rather than adding new meaning, and it says nothing about resolving the document vs documentPath or inspectAssets vs inspectAssetsPath pairs.

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 specific verbs and resources: it classifies inspect_document layers into four named categories and generates a deterministic export plan plus optional JSON manifest. The purpose is unmistakable, but no sibling tool (e.g., inspect_ui_project, extract_design_tokens, sync_figcraft_assets) is referenced to help an agent choose between this and neighboring asset/design 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 one explicit usage rule — 'Supply the raw inspect_document JSON, not a screenshot' — is genuinely useful input guidance. However, there is no statement of when to prefer this over alternatives (e.g., extract_design_tokens or inspect_ui_project) or prerequisites such as needing a prior inspect_document call, so usage is only implied.

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

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

With no annotations, the description carries the full burden. It discloses the Playwright dependency and that it returns prioritized issues and mismatch regions, but does not state side effects such as writing screenshots/heatmaps to disk or how overwrite affects prior output. This is partial but not complete behavioral context for a 10-param 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?

A single dense sentence that front-loads the core action and return value, with the Playwright requirement appended last. No wasted framing, though the requirement could be separated for scannability.

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 complex 10-parameter tool with no output schema and no annotations, the description gives a reasonable conceptual picture of the return (prioritized issues, mismatch regions) and the key prerequisite. However it omits side-effect/file-output details and the relationship to the granular sibling tools, leaving gaps an agent must infer.

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 high (~80%), so the schema already documents most parameters including ranges and defaults. The description adds only the mapping of 'optional FigCraft reference comparison' to the referenceImages concept; baseline 3 is appropriate when the schema does the heavy lifting.

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 clear compound verb+resource: capture and audit a real localhost web UI in one browser pass, optionally comparing FigCraft references and returning prioritized issues. The phrase 'in one browser pass' implicitly distinguishes it from the granular siblings (capture_ui_screenshots, compare_ui_screenshots, audit_ui_page), though it never names them.

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 prerequisite 'Requires project-local Playwright' is a useful usage gate, and 'optionally compare' flags conditional behavior. But there is no explicit guidance on when to choose this over the dedicated capture/compare/audit siblings, leaving the primary routing decision to inference.

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

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

No annotations are provided, so the description carries the full disclosure burden. It does note the non-destructive default and the returned path/checksum, but omits whether network access is required, what happens for unknown icon identifiers, how files are named, and whether the overwrite flag replaces or merges changed files. For a filesystem-writing tool with zero annotation coverage, that is a meaningful gap.

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

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

Two front-loaded sentences with zero waste: the action and scope come first, then the return shape. Nothing is redundant.

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 usefully says it returns a path and checksum per icon, closing the main return-value gap. Remaining omissions are error/failure behavior and network requirements, which keep it from a 5.

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%; each of dir, icons, height, and overwrite is documented including defaults. The description only echoes the overwrite default already in the schema and adds no meaning beyond it, 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 and resource: downloading a group of Iconify SVG icons from a single family into a local project folder. The batch/file-write nature implicitly separates it from get_icon and find_icons, but no sibling is named explicitly.

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 batch-persist scope implies when to reach for it, but the description never says when to prefer it over get_icon (single fetch) or find_icons (discovery), nor does it state prerequisites such as family consistency or the 40-icon cap for batching.

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

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

With no annotations, the description must carry the whole behavioral burden. It does disclose two real traits: binding is localhost-only and hidden files are blocked. But it says nothing about server lifecycle — whether 'start' launches a persistent background process, what it returns (a URL/port?), whether repeated starts stack, or how 'stop' identifies which server to stop when no port is supplied.

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 sentences, front-loaded with the core capability and followed by the two constraints that matter most. No filler, no restatement of the title, and the security warning lands where a reader will actually see 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?

For a tool that starts and stops a server process, the missing pieces are lifecycle and return information: does start yield a URL the agent can hand to a user, and is the server persistent across later calls? With no annotations and no output schema, the description is the only place those could be stated, and they aren't. Adequate for the happy path, incomplete for an agent managing a running process.

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 per-parameter descriptions already covering the port fallback behavior, the root default of '.', and the action default of 'start'. The description adds no parameter-level detail beyond that, so the baseline 3 applies rather than a higher score.

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 precise verb pair ('start or stop') and a precisely scoped resource ('localhost-only static preview for HTML, CSS, JS, and SVG'). The 'Not a deployment service' line pre-empts the most likely misreading, though no sibling is named — the other tools in the set (icons, design tokens, screenshots) are far enough away that explicit differentiation isn't critical.

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?

Gives clear context for when this applies (local static preview of web assets) and an explicit exclusion via 'Not a deployment service'. It also warns against serving files with secrets, which is a use-time constraint. It stops short of naming an alternative tool for handoff/deployment scenarios, which the sibling list suggests exists (prepare_web_handoff).

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

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

With no annotations, the description carries the full burden. It usefully discloses that only manifest-listed files are copied and that hashes/missing files/conflicts are recorded, but says nothing about overwrite semantics (the overwrite param exists in the schema, but its effect isn't described), permissions, or whether the operation is idempotent.

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 tight sentences with zero filler; the positive behavior comes first and the scope exclusion is front-loaded at the end. Every clause earns its place.

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 file-writing tool with no annotations and no output schema, the description is only partly complete: it never explains overwrite behavior, what happens on conflict, or what the recorded results look like. The schema fills in defaults, but mutation semantics are left implicit.

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 3 applies. The description adds mild value by tying the handoff manifest, the export directory, and the <publicDir>/figcraft destination together conceptually, but adds no format or default details beyond the schema.

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

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

States a specific verb and resource (copy manifest-listed files from the FigCraft export dir to <publicDir>/figcraft) and adds a negative scope clause: 'Does not export from FigCraft itself,' which separates it from the sibling prepare_web_handoff. The only gap is that it doesn't name prepare_web_handoff as the prerequisite, though the schema field for handoff does.

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

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

'Does not export from FigCraft itself' implies the agent should call the export/handoff step first, but neither the ordering nor the alternative tool is stated explicitly. There are no exclusions beyond that single clause and no prerequisites spelled out.

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