mcp-ui

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

No annotations exist, so the description carries the full behavioral burden. It does disclose the return payload (reachability, status, latency, 24h summary) and that the probe is 'live,' which is useful. However it omits operational traits an agent would want for a network probe — timeouts, rate limits, whether the 24h summary requires prior history, or caching — leaving meaningful behavioral gaps.

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, well front-loaded with the core action and returns before the usage hint. The 'Inputs:' clause partially duplicates the schema, but it reads efficiently and wastes little.

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, so the description must describe returns, and it does so explicitly (reachability, HTTP status, round-trip latency, 24h summary). It stops short of clarifying what the '24h summary' contains (e.g., percentages vs. raw samples), but is otherwise sufficient 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 baseline is 3. The description restates `endpoint` (required) and the `method` GET/HEAD enum, but adds no syntax, validation, or format detail beyond the schema, and never mentions the `locale` parameter at all. It adds little parameter-level meaning.

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 ('Run a live health check') and resource ('public API endpoint'), then enumerates exactly what it returns (reachability, HTTP status, round-trip latency, 24h uptime/latency summary). An agent can distinguish it from network-adjacent siblings like dns-lookup or http-inspector without opening any 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?

Explicitly states when to use it: 'when a user wants to check whether an API or website is up, or compare response latency.' Clear context, but it names no alternatives or exclusions (e.g., how it differs from the sibling http-inspector), so routing among similar tools 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 full burden. It helpfully discloses the output shape (four bases plus a bit array), which is real behavioral context, but says nothing about validation limits, how out-of-range values are handled, or the effect of `bits` on the representation.

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 with the capability front-loaded and the parameter hints trailing. No filler, though the inline parameter listing reads slightly clunky.

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?

Three parameters with zero schema descriptions and no output schema or annotations means the description is the only documentation. It leaves `locale` undocumented and does not clarify defaults or value-range behavior, which is not enough for an agent 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 0%, so the description must compensate. It names `value` and adds the allowed bit widths for `bits` (8/16/32) that the schema does not provide, but it omits the `locale` parameter entirely and never explains the defaults or required-ness.

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 ('Show') and resource ('an integer in base 2/8/10/16 and as a bit array'), so the agent knows exactly what it produces. It is distinguishable from utility siblings like unit-converter or hash-generator, though it does not explicitly name a sibling it is not.

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 for bit math or base conversion' gives an implied context for invocation, but offers no when-not guidance, no prerequisites, and no named alternative for overlapping tasks. Adequate but 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?

With no annotations, the description carries the full behavioral burden. It usefully discloses that two output forms are produced (financial capital and plain Chinese numerals), but says nothing about rounding/precision, negative or zero handling, or max supported magnitude for a money formatter.

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, front-loaded with the core action and followed by the use case. The 'Input: `amount`' fragment is mildly redundant with the schema, keeping it just below top marks.

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 and no annotations, so the description must stand alone. It covers the transform and one use case but leaves the locale effect and output/edge-case behavior unexplained, which is a real gap for a formatter with a configurable output language.

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%. The description only names 'amount' and never explains the 'locale' parameter (en/zh) or what it changes about the output, so half the parameters remain semantically opaque beyond the bare enum.

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 ('Convert an amount to Chinese financial capital numerals (人民币大写) and Chinese numerals'), naming the exact output notation rather than a generic 'convert'. No sibling does currency/numerals conversion, so it is unambiguously distinguishable.

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 for invoices or cheques' gives a concrete usage context that helps an agent route to it. It stops short of exclusions or naming alternatives (e.g. unit-converter), so it is clear context without full when/when-not 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 disclose the return contents (pillars, five-element distribution, day-master strength, luck cycles) plus a cultural/entertainment-only caveat. It is a pure computation with no side effects, so remaining gaps (determinism, input validation) are minor.

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: purpose first, output inventory second, usage scope and disclaimer last. Every sentence earns its place and 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?

There is no output schema, but the description enumerates the returned fields in enough detail for an agent to decide whether the result fits a downstream need, and the disclaimer sets expectations. Nothing material is missing for a 4-param, deterministic calculator.

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 schema already documents each parameter, including the gender rationale and the 12:00 time default. The description only restates birth date/time/gender, adding no format or edge-case guidance 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?

States a specific verb and resource ('Compute a BaZi chart from a birth date, time and gender') and enumerates the outputs, so an agent can immediately tell this apart from computation siblings like compound-interest or statistics.

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 scopes use to 'Chinese metaphysics / fortune-telling requests that need a birth-chart analysis', which is clear context for when to call it. It doesn't name alternatives, but no sibling tool overlaps, so there is little to disambiguate against.

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 does disclose that this is a pure simulation (read-only in effect) and states the return values ("simulated hex values"), but it says nothing about the locale parameter's effect or whether output is a list of per-deficiency values.

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. Purpose, input format, return value, and a usage cue are all covered 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?

With no annotations and no output schema, the description does the essential work by stating inputs and return values. It is adequate for a simple two-parameter tool, but the undisclosed locale parameter leaves a small completeness 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 0%. The description documents the color input as hex, which the schema does not, so it adds real value there. However, the second parameter (locale enum) is completely undocumented in both schema and description, leaving a 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 (simulate) plus the exact resource and the three simulation modes (protanopia/deuteranopia/tritanopia). This clearly distinguishes it from sibling color tools like color-palette and color-studio, which shift/manipulate colors rather than simulate deficiencies.

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 for accessibility checks" gives a clear context of use, but there are no exclusions or named alternatives among the many sibling color tools. The usage is implied rather than fully guided.

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

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

No annotations are provided, so the description must carry the full behavioral burden. It discloses the input format and return values ('palette hex values') but says nothing about determinism, side effects, permissions, or the harmony algorithm. Adequate for a simple generator, but not rich.

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 short sentences, front-loaded with generation purpose, then input, return, and usage. No redundant or wasted wording.

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 generator with no output schema, the description covers the main action and return type. It leaves the 'locale' parameter unexplained and omits any behavioral guarantees, 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 0% and there are two parameters. The description documents only 'color' as a hex input, adding format detail beyond the schema, but entirely omits the optional 'locale' enum parameter and its default.

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?

Specifies verb 'Generate', resource '5-color harmonious palette', and source 'base color'. The core purpose is clear, though it does not distinguish itself from sibling tools like color-studio or color-blindness.

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?

States 'Use when a user needs a color scheme', giving clear context for invocation. It omits when not to use the tool or which sibling alternative is preferred, so it is not a 5.

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 the full computed surface (luminance, WCAG ratios with AA/AAA flags, recommended text color, tint/shade scale), which signals a pure read-only analysis operation with no side effects. It stops short of stating that there is no persistence or state change, but the nature of the tool makes that low-risk.

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: the first is a front-loaded what-it-does plus output list, the second is the usage cue. No filler, and the most scannable information (analyze a color, returns contrast data) leads.

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 must explain return values — and it enumerates them completely (hex/RGB/HSL, luminance, contrast ratios with pass flags, recommended text color, tint/shade scale). Combined with the tiny two-param surface, an agent has everything needed to select and invoke it correctly.

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

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

Schema description coverage is 100% and both parameters (color, locale) are documented in the schema itself, so the description adds little param-level meaning beyond repeating the accepted color formats. 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?

Uses a specific verb ('Analyze') on a specific resource ('a color given as hex, rgb() or hsl()') and enumerates the exact outputs, making it easy to tell apart functionally from color-palette (palette generation) and color-blindness (simulation). It never names a sibling explicitly, so it stops just short of full sibling differentiation.

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

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

The closing sentence gives an explicit use condition: 'Use this when a user asks to convert a color or to check color accessibility/contrast.' That is clear routing guidance, but there are no when-not conditions and no named alternatives (e.g., color-palette) for overlapping color requests.

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 disclosure burden. It usefully states the output shape ('Returns yearly values') and the return granularity, plus the compounding default, but says nothing about rate/period conventions, precision, or edge cases (zero years, negative rate).

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 short sentences, front-loaded with the purpose and then the input contract. Every clause earns its place; only the slightly telegraphic input list keeps it from a 5.

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 low-risk pure-computation tool with no output schema, the description gives an adequate contract, but the undocumented locale parameter and unspecified output structure leave gaps an agent cannot fill from structured data.

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 documents principal, rate (with the 'annual %' unit) and compounds (per year, default 12), which adds real meaning, but it completely omits the locale enum parameter, leaving one of five inputs unexplained.

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 ('Project') and resource ('compound interest') with the key inputs, so the purpose is unambiguous. It does not differentiate itself from the financially adjacent sibling loan-calculator, so it stops short of a 5.

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 use this versus alternatives like loan-calculator, nor any stated prerequisites or exclusions. The agent must infer context from the name 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?

No annotations exist, so the description carries the full burden, and it does disclose the return payload (standard equation, foci, eccentricity, directrix, asymptotes). It does not say how irrelevant parameters are handled (e.g., supplying p for a circle) or anything about failure modes, so it stops short of full transparency.

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

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

Front-loaded with the purpose, then inputs, then returns, then intended use – every clause earns its place and nothing is padded. Slightly dense inline enumeration but efficient overall.

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 pure computation/rendering tool with no annotations and no output schema, the description covers purpose, inputs and returned values, which is most of what an agent needs. Gaps remain around parameter applicability per conic type, the locale-driven rendering side effect, and error behavior.

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 five parameters including the type enum and locale are already documented in the schema. The description restates a/b/p semantics and adds the y²=2px convention, which is consistent but largely redundant; the locale parameter is not mentioned at all.

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 ('Plot a conic section') and enumerates the four supported types plus the returned quantities. It is distinguishable from nearby math/graphing siblings (function_grapher, geometry-lab, trig-lab) by topic and by the conic-specific outputs, though it does not name a sibling to differentiate against.

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 for high-school conic-section teaching' implies the intended context but gives no when-not conditions, prerequisites, or alternatives (e.g., vs function-grapher for arbitrary curves). Usage is implied rather than specified.

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 cron path computes the next 5 fire times and that the regex path returns matches, which is useful output behavior, but it says nothing about invalid-expression handling, error behavior, or that the operation is a side-effect-free computation.

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 primary action and ending with the usage triggers. Efficient and zero filler, though the 'Inputs:' sentence partially restates schema content; it does earn some of its place by clarifying the and/or relationship between the two 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 two-mode tool with 5 all-optional parameters, no annotations, and no output schema, the description covers both modes and their outputs adequately. The gap is minor: it does not state behavior when conflicting or missing inputs occur, and omits the locale parameter.

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 restates the key inputs (cron as a 5-field expression; regex with optional flags and text) but adds little format or constraint detail beyond the schema, and never mentions the locale parameter at all.

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 two specific verbs and resources: explaining a cron expression (with next 5 fire times) and testing a regex against sample text. This is concrete enough that an agent can tell exactly what the tool produces, and it is readily distinguishable from the sibling tools, none of which overlap with cron/regex debugging.

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 final sentence gives explicit trigger conditions: when a schedule runs, when verifying a cron format, or when testing/debugging a regex. That is clear when-to-use guidance, but it offers no exclusions or named alternatives, and does not clarify what happens if neither input or both inputs are supplied.

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

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

With no annotations, the description carries the full burden; it discloses that all inputs are optional and that the tool returns "the resulting CSS," which is useful. It does not explain whether only the selected tab's parameters are honored, how defaults interact with `tab`, or that the operation is a pure non-mutating generator, leaving real behavioral gaps.

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 tool's identity and tabs, then inputs, then return value, then usage trigger — every sentence earns its place with no filler.

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

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

For a 16-parameter tool with no annotations and no output schema, the description covers the input surface well and states the return (CSS), but leaves `locale` undocumented and never clarifies the tab-to-parameter interaction or default behavior, which an agent needs to call this 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 0%, so the description must compensate, and it does materially: it groups all parameters by tab (gradient from/to/angle/kind; shadow x/y/blur/spread/color/inset; radius tl/tr/br/bl), which tells the agent which knobs belong to which mode. It omits the 16th parameter `locale`, and gives no units for `angle` or color-string format, so it is good but not complete.

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+resource — an interactive CSS studio producing gradient/shadow/border-radius CSS — and enumerates the three tabs, so the agent knows exactly what it generates. It does not name any sibling (e.g. color-palette, color-studio), so differentiation is left to inference 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?

"Use when a user wants a gradient, shadow or rounded-corner CSS" is an explicit when-to-use trigger tied to recognizable user intents. There are no when-not conditions or named alternatives, so it stops short of 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 full burden. It does disclose return content ('headers, row count and numeric columns') and the rendering behavior, which is genuine added context. However, it says nothing about malformed CSV, non-numeric columns, missing required input, or size limits — notable gaps for a parse-and-render 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 short sentences, front-loaded with the core action, then input format, then return shape. No filler and every clause carries information.

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

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

With no output schema and no annotations, the description does reasonably well: it covers the input format and the key return fields. But the silent `locale` parameter and the absence of any failure-mode or size-limit context leave meaningful gaps for a tool that must parse arbitrary CSV.

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 documents `csv` partially ('first row = headers') but never mentions the `locale` parameter (enum en/zh) that appears in the schema, leaving half the parameters semantically unexplained anywhere.

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

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

The description opens with a specific verb+resource: 'Turn CSV into a chart.' That is unambiguous and distinguishable from siblings like echarts or function-grapher, which operate on different inputs. It stops short of explicitly naming which sibling to use instead, so it lands at a clear-but-not-differentiating 4.

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 when-to-use guidance and no routing to alternatives such as echarts, function-grapher or statistics, all of which could plausibly consume structured data. The mention that 'the card renders a bar/line chart' implies display context but does not tell an agent when this tool is the right choice versus a sibling.

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 disclosure burden. It usefully states the return shape (individual results plus total) and the count range 1–20, and hints at fairness/trustworthiness, but says nothing about determinism, seeding, or repeatability that the 'trust' phrasing gestures at.

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 verb and inputs, then the return shape, then the use case. No filler and nothing 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?

For a simple stateless tool with no output schema, the description covers the action, the two main inputs, and the return value. It still leaves the locale parameter and its purpose unexplained, a real gap given 0% schema description coverage.

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 documents count (1–20) and sides with examples, but completely omits the third parameter locale (enum en/zh), leaving one of three parameters undocumented anywhere.

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 ('Roll dice') and the two core inputs, so the agent knows exactly what the tool produces. It does not differentiate itself from the conceptually adjacent sibling random-picker, but the core purpose is unambiguous.

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

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

The final sentence gives an implied use case ('tabletop games or random rolls the user should be able to trust'), which hints when to reach for it. There is no explicit when-not guidance or named alternative (e.g. random-picker), 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It says it "Returns the answer records" but is silent on lookup failure behavior (NXDOMAIN, timeouts), whether results are cached, and whether it reaches the public resolver or an internal one. The `locale` parameter's effect on behavior is never explained.

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 no padding; the core action leads. The closing "Use to check DNS" is redundant with the opening sentence and could be dropped, but the overall shape 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?

For a simple three-parameter lookup with no annotations and no output schema, the description covers the essentials of calling it. It stops short of describing the response structure or failure modes, leaving the agent to guess what to do when a lookup returns nothing or errors.

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 0%, so the description must carry the load, and it does for two of three parameters: it clarifies `name` as a domain and enumerates valid `type` values (A/AAAA/CNAME/MX/TXT/NS) that appear nowhere in the schema. It omits `locale` entirely, which keeps this from being a 5.

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 ("Resolve DNS records") along with the inputs and the shape of the return ("answer records"), so an agent knows exactly what the tool produces. The sibling list contains only unrelated utilities (hash-generator, world-clock, etc.), so no differentiation is possible or needed.

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 to check DNS" restates the purpose rather than giving real guidance — there are no prerequisites, no when-not conditions, and no alternatives named. Usage is only implied, which is the definition of a 3.

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 disclose real behavior: clicking a data point sends a follow-up message for drill-down when enableInteractivity is true (default), the card auto-applies dark theme/axis/legend/tooltip styling, and output must be valid JSON with no comments or functions. It omits any limits on chart size, data volume, or failure modes, so it stops short of 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?

Front-loads the core purpose and chart-type list before inputs and constraints, and every sentence contributes something. It is fairly dense and repeats the template guidance already living in the option schema description, costing a point.

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 six parameters, nested option objects, and no output schema, the description covers the essential ground: what to render, required vs optional inputs, interactivity side effects, and input validity rules. Return/render semantics beyond 'a card appears' are left implicit, which is a minor 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 the baseline is 3. The description restates required/optional status (option required; title, subtitle, insights optional) and the interactivity semantics, but leans on the schema's own templates rather than adding new meaning for locale or the option shape.

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 ('Render an interactive Apache ECharts chart from a standard ECharts option JSON object') and enumerates the supported chart types via series[].type. This clearly separates it from siblings like csv-chart, function-grapher, and bit-visualizer without needing to open a 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?

Gives explicit usage context: 'Use this whenever a user would benefit from a chart or data visualization instead of raw numbers.' It tells the agent when to reach for this tool, but names no exclusion cases and does not point at competing siblings such as csv-chart for tabular input.

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 more burden, but it does disclose meaningful behavior: the tool is an 'interactive card' (a UI widget, not a headless transform) and the result is 'downloadable as PNG'. It omits whether the operation has side effects, persistence, or auth needs, but for an apparently client-side renderer this is acceptable 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?

A single efficient sentence with the core purpose front-loaded and no filler. Slightly dense but nothing wasted.

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 and no annotations, so the description must stand alone; it adequately conveys what the tool produces but leaves the sole schema parameter (locale) unexplained. Marginally complete for a low-complexity 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?

The schema has one parameter (locale, with an enum and default) at 0% description coverage, and the description never mentions it. Worse, the description lists 'text/emoji, background, foreground and radius' as inputs, which are not schema parameters — this risks confusing the agent about what it can actually pass.

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 resource (favicon) and enumerates what it renders (text/emoji, background, foreground, radius) plus the output form (PNG). It is clear what the tool produces, though it makes no attempt to differentiate itself from any sibling.

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

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

The description explains what the tool renders but gives no guidance on when to reach for it, no prerequisites, and no alternatives. An agent infers the use case (favicon creation) but nothing is stated.

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

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

No annotations are provided, so the description carries the full burden. It does disclose the deterministic outputs (equation, vertex, axis of symmetry, discriminant, asymptotes, monotonicity) and that missing params fall back to defaults, but it says nothing about side effects, error behavior for mismatched params/family, or whether results are purely computational and repeatable.

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 front-loaded sentences with no filler: purpose, parameter contract, return payload, and use case, in that order. The param examples are dense but every clause carries information; the sole mild cost is that the middle sentence is a long run-on mixing inputs and outputs.

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 compensates by enumerating the returned features, and it covers the family enum, param shape, defaults, and a use case. It stops short of describing failure modes (e.g. an unknown key in `params`) or confirming the operation is idempotent, but nothing essential for a correct call is missing.

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

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

Schema coverage is already 100%, so baseline is 3, but the description genuinely adds meaning the schema does not: it maps which param keys belong to which family ({"a","b","c"} for quadratic, {"k"} for linear/inverse, {"a"} for exponential/logarithmic/power). That mapping would otherwise be guesswork, and the interaction between `family` and `params` is clarified. Only `locale` is left unaddressed, which the schema covers.

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 ('plot and explore') and a specific resource ('a common function'), then enumerates the supported families, which cleanly separates it from graph-adjacent siblings like trig-lab, conic-sections, and geometry-lab. An agent can identify the tool's job 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?

Explicitly scopes usage: 'Use this for middle/high-school math when a user asks to draw or explain a function graph' — a clear trigger condition. It lacks any when-not guidance or named alternatives (e.g. trig-lab for trigonometric functions), so it falls short of a 5.

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, so the description carries the full burden. It usefully discloses the return payload (side lengths, angles, perimeter, area, triangle classification flags, and theorem checks), which is real behavioral value. It fails to state that a rendered card is produced (only inferable from the locale param) or any side effects, so transparency is partial.

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 with no filler, inputs listed before outputs. It is information-packed rather than rambling, though the output clause is a long run-on that slightly hurts 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?

With no output schema, the description correctly spends its words describing return values, and it covers all four parameters including defaults. An absent annotation layer means a note on the rendered-card side effect would complete it, but nothing essential for calling the tool is missing.

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

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

Schema description coverage is 100%, so the schema already documents shape, points, radius and locale. The description restates the shape enum, the point-array-per-shape constraint and the circle radius, adding only mild emphasis ("optional") beyond the schema. 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 resource (plane geometry) and enumerates the computed outputs, so an agent knows what the tool produces. The verb is soft ("interactive") and it never names sibling geometry tools like conic-sections or trig-lab, so differentiation is left to inference.

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 for middle-school geometry teaching" gives a target scenario, which is more than nothing. However, there is no when-not guidance and no routing against adjacent siblings (conic-sections, trig-lab, function-grapher), so selection still requires 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 full behavioral burden and does well: it discloses the division of labor (validation/win detection here, opponent moves in the host), the input ordering rule (black first, play order), and the return contents (board state, whose turn, winner). It stops short of stating how illegal or out-of-turn moves are handled or what happens on a draw.

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?

Compact and front-loaded: purpose first, then mechanism, then inputs, then return values, then the usage trigger. Every sentence earns its place and nothing is padded.

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 the key return fields (board state, turn, winner). For a game-state tool with 4 optional params this is nearly complete; only edge-case behavior (invalid move, draw) is unaddressed.

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 four parameters are already documented, and the description largely restates them (moves example format, humanColor default, size). The added value is the 'play order, black first' semantics on moves, but this is marginal over 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 resource (a Gomoku board) plus concrete verbs: it provides the board, validates moves and detects wins. It also clarifies a non-obvious architectural fact — the opponent AI lives in the host application, not this tool — which distinguishes its role clearly from the surrounding utility siblings.

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 this when a user wants to play five-in-a-row against the assistant" gives a clear usage trigger. There are no competing siblings to route against, so no exclusions are needed, but it also doesn't state when it is not appropriate (e.g. when the host wants to run its own game engine).

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

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

No annotations are provided, so the description carries the full burden. It discloses useful traits - output formats (hex and base64) and the client-side Web Crypto implementation - but says nothing about determinism, side effects, input limits, or whether anything is transmitted.

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 core purpose front-loaded and no significant padding. The final sentence on Web Crypto is marginal but relevant; slight redundancy between 'hash a value' and 'generate a digest'.

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 compensates by stating the return formats (hex and base64). It is nearly complete for a stateless compute tool, though it omits the rendered-card nature implied by the 'locale' parameter.

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. The description restates the algorithm names but adds no meaning beyond the schema and never explains the 'locale' card-rendering parameter. Baseline 3 applies 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 specific verb (compute) and resource (cryptographic hash digests) plus the exact algorithms supported, so the agent knows precisely what this tool does. It does not name or distinguish itself from any sibling, though none of the listed siblings directly compete on hashing.

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 names the triggering intents ('hash a value, verify a checksum, or generate a digest'), giving the agent clear context for selection. There are no exclusions or alternative tools named, but none are needed given the absence of a competing sibling.

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. It usefully states that the fetch is server-side and lists the returned artifacts (status, redirect chain, headers), but it does not cover request method, side effects, timeouts, auth, or rate limits.

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

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

Two short sentences with the core action and return values front-loaded. There is no filler, and the usage note follows naturally.

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 no output schema and no annotations, the description does explain the returned values well. However, it leaves the locale parameter undocumented and omits operational details such as timeout or redirect-limit behavior.

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% and the description only says 'Input: url', adding little beyond the schema's required url field. It entirely omits the locale parameter, so an agent gets no semantic guidance for that enum option.

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: it fetches a URL server-side and returns HTTP status, redirect chain, and response headers. It clearly defines what the tool does, though it does not explicitly differentiate itself from potentially related siblings such as dns-lookup or api-uptime.

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 says to use the tool to debug HTTP responses, and adds a concrete limitation that a browser cannot do this cross-origin. This gives clear usage context, but it does not state when not to use it or name specific alternatives.

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 does disclose a genuine trait beyond a plain function: this renders an interactive card with a slider and format selector rather than performing a silent server-side transform. However, it omits whether compression happens client-side, which formats are supported, and any size limits.

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

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

A single front-loaded sentence with no filler; the interactive nature and the before/after feedback are stated up front. It is appropriately sized for a widget tool, though the phrase 'compresses an image' mildly restates the tool 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?

With no output schema and no annotations, the description should at least clarify the invocation model. It describes the resulting card well but leaves open how the image is provided (no image parameter exists) and never touches the locale parameter, so the definition is adequate but incomplete 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?

The single parameter (locale, enum en/zh, default en) has 0% schema description coverage and is never mentioned in the description. The only 'format choice' referenced is a UI control inside the card, not the locale parameter. The description does not 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?

The description states a concrete verb and resource ('compresses an image') and goes further by enumerating the card's contents: quality slider, format choice, before/after sizes. It is distinguishable from siblings like image-to-base64 or color-studio. It stops short of explicitly contrasting itself with those alternatives, so it lands at 4 rather than 5.

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

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

The usage is only implied — an agent can infer it should render this card when the user wants to compress an image, but there is no explicit when-to-use statement, no prerequisites, and no routing away from siblings. Notably absent is any guidance on how the image itself is supplied, which is the main invocation ambiguity.

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 it does disclose two useful behaviors: the output form (data URI / Base64) and that execution is client-side ('Runs fully in the browser'), implying no upload. However, it says nothing about size limits, supported image formats, 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?

Two short sentences with no padding, and the core purpose is front-loaded ahead of the browser-execution note. Efficient, though the 'interactive card' framing is slightly ambiguous about what the caller actually receives.

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 client-side conversion utility with no output schema and no annotations, the description covers purpose and execution context adequately. It is incomplete regarding the locale parameter and any constraints on input images, leaving some gaps 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?

The single 'locale' parameter has 0% schema description coverage and the description never mentions it, so it adds no meaning beyond the enum values (en/zh) already visible in the schema. For a low-coverage parameter, the description should compensate but does not.

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 (converts) and resource (image) with a precise output target (data URI / Base64), which distinguishes it from the sibling image-compressor. It is clear what the tool does, though it does not explicitly name an alternative it should not be confused with.

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 guidance or routing versus alternatives such as image-compressor or favicon-generator. The phrase 'interactive card' only loosely implies this is a UI-driven tool, leaving the agent to infer the scenario on its own.

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

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

With no annotations provided, the description carries the full burden. It discloses the critical behavioral trait that no signature verification occurs, and it describes the return shape (header, payload, standard claims, expiry status) in detail. It omits minor operational details like rate limits or security caveats, but the essential behavior is clear.

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

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

Three sentences, each earning its place: the first states the core action and a key differentiator, the second enumerates the return values, and the third gives the usage trigger. It is front-loaded and free of 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, read-only decoding utility with complete input schema coverage and no output schema, the description provides everything needed: the action, what it does not do, the output contents, and the usage scenario. No meaningful gaps remain for an agent to call it correctly.

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

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

Schema description coverage is 100%, so both the 'token' and 'locale' parameters are fully documented in the schema. The description adds no parameter-level information beyond what the schema already provides, which is acceptable given the high 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 states a specific verb ('Decode') and resource ('JWT'), and immediately clarifies the scope by specifying it does not verify the signature. This distinguishes it from any hypothetical verify tool and tells the agent exactly what the operation 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?

It gives a clear usage context: 'Use this when a user pastes a JWT and wants to inspect its contents.' No alternative tools exist among the siblings for JWT inspection, so explicit when-not guidance is unnecessary; the context is sufficient.

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

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

With no annotations, the description carries the full behavioral burden. It helpfully discloses the return payload (monthly payment, total interest, total paid, balance schedule), but it omits calculation assumptions, the effect of the locale parameter, and the format of the balance schedule.

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 tool's purpose, and structured as inputs and returns. Every phrase earns its place with no filler.

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

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

For a simple calculator with no annotations, no output schema, and 0% schema description coverage, the description is adequate but incomplete. It explains the main return values but leaves gaps around the locale parameter, defaults, and the meaning of the balance schedule.

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 explains three of four parameters and adds a useful unit for rate ('annual %'), but it completely omits the locale parameter and gives no default values or further meaning for principal and months.

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: 'Compute a loan.' It also lists the expected inputs and outputs, making the tool's purpose clear. However, it does not differentiate this tool from related siblings such as compound-interest, so it stops short of a 5.

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

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

The description gives no explicit when-to-use or when-not-to-use guidance, and it does not mention alternatives such as compound-interest. Usage is only inferable from the name and purpose statement.

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 state the return shape ('resulting matrix or scalar'), which is useful, but is silent on failure behavior such as dimension mismatches for multiply or invalid matrix text. For a pure compute tool this is acceptable but incomplete.

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 compact sentences, front-loaded with the purpose and then the inputs and output. The inline format example is the only elaboration and it earns its place by disambiguating an otherwise opaque string parameter.

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 four parameters, no annotations, and no output schema, the description needs to work harder. It covers the core contract and return type, but omits `locale` and any error/edge-case behavior, so an agent lacks full information for non-default calls.

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 does well for `a`, `b`, and `op`, including the newline-row format with a concrete example and the semantics of each operation. However, the fourth parameter `locale` (enum en/zh) is never mentioned, leaving one of four parameters entirely 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?

The description names a concrete resource (matrices) and enumerates the supported operations ('multiply' | 'transpose' | 'determinant'), so an agent can tell this apart from neighbors like unit-converter or statistics. It stops short of naming a sibling or scoping the tool against an alternative, which keeps it at 4 rather than 5.

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 only implied through the list of operations; there is no explicit 'use this when...' statement or exclusion of alternatives. For a self-contained math utility with no real substitute among the siblings, implied usage is adequate but does not add 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?

No annotations are provided, so the description carries the full burden. It usefully discloses the return shape and a privacy guarantee (the value is not stored), but says nothing about the estimation method, whether it is a local vs network computation, or any rate/permission considerations.

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 purpose, input, output, and a usage hint front-loaded. No filler, though the "Input: `password`" fragment barely 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 simple two-param tool with no output schema, the description does cover the return values, which is the main gap it needs to fill. However, the undocumented `locale` parameter and the silent estimation methodology leave it only partially 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 0%, so the description must compensate. It names the `password` parameter but adds no semantics beyond the schema's type, and omits the `locale` enum parameter entirely, leaving one of two parameters undocumented in both places.

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 ('Estimate a password strength') and enumerates the return values (0–4 score, label, entropy bits). This is clearly distinguishable from the utility siblings, none of which touch password analysis, though it does not explicitly name any sibling it differs from.

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 to advise users" implies a usage context but gives no when-not conditions, prerequisites, or alternatives. It is adequate as a hint but not a real routing rule.

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 the post-invocation behavior ("the card renders and lets the user download a PNG"), which the schema does not reveal. It says nothing about failure modes, encoding limits, or whether the QR is stored/returned as data, so gaps remain.

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 purpose and the usage trigger, with no filler. The "Input: `text`" clause is slightly redundant against the required-field schema, which keeps it from a top score.

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, no-output-schema tool this is roughly adequate: it covers purpose, the triggering use case, and the visible outcome (rendered card, PNG download). The unaddressed `locale` parameter is the main completeness hole, since nothing explains when or why to set it.

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 and it only half does. It names `text` as the input, but says nothing about what the value is used for at the encoding level, and completely omits `locale` (en/zh), leaving an agent to infer its effect from the enum 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?

The description opens with a specific verb and resource ("Generate a QR code for a text or URL"), which is unambiguous about what the tool produces. No sibling in the list does anything similar, so differentiation is trivially satisfied, but it also does not reach the level of a description that actively contrasts itself against a competing 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?

"Use when a user wants a scannable QR code" gives an explicit trigger condition, which is better than nothing. However it states no exclusions, prerequisites, or alternatives, and it largely restates the purpose, so it only implies usage rather than guiding selection.

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

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

No annotations are provided, so the description carries the full burden, and it does so well: it discloses that the card paginates, lets the user answer single/multiple choice, computes a total, and sends selections and score back through the conversation. That round-trip behavior is non-obvious and important. It omits any auth/permission or rendering-failure behavior, keeping it just 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?

The definition is front-loaded with the core purpose and the model/card division of responsibility, then walks through inputs and behavior in ordered sentences. It is dense rather than bloated, though the 'Inputs:' enumeration partially restates schema fields and could be tightened.

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 must explain the return path, and it does ('sends the selections and score back through the conversation so you can respond'). Nested question/option structure is also covered. The unexplained locale parameter and absent pagination edge cases keep it from a perfect score.

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, but the description adds genuine meaning beyond the schema: it documents the perPage default of 1, the question object shape, the option { label, score } form, the bare-string alternative with a 'parallel scores array', and that scores can be negative. Only the locale parameter's role is left to 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 opening sentence states a specific verb and resource ('Render an interactive quiz') and immediately clarifies the division of labor: 'The card only renders; YOU (the model) define everything.' An agent knows exactly what this tool produces and how it differs from sibling visualization utilities like typing-test or random-picker.

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 clear trigger conditions ('Use whenever a user wants a test, quiz or questionnaire'), which is strong positive guidance. However, it offers no exclusions or routing against the closest siblings (typing-test, reaction-test, random-picker), so it falls short of the explicit when-not guidance needed for a 5.

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

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

No annotations are provided, so the description carries the full burden. It usefully discloses crypto-randomness (implying fairness/uniformity) and that one item is returned, but says nothing about behavior on an empty list, duplicate handling, or how the locale parameter affects output.

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 with the core action front-loaded and no filler. Slightly clipped style ('Input: `items` (array). Returns the chosen item.') is efficient rather than noisy.

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 one-required-param tool with no output schema, the description covers input, output, and purpose adequately. The unexplained `locale` parameter and absent edge-case behavior keep it from being fully 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 0%, so the description must compensate. It documents only `items` (array) and skips the `locale` enum parameter entirely, leaving a required-looking dimension of behavior unexplained in both schema and prose.

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: 'Pick one item at random from a list', and adds the mechanism ('crypto-randomness'). Clear enough to distinguish from randomness-adjacent siblings like dice-roller, but it does not name or contrast with any sibling 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?

'Use for fair raffles or decisions' implies a usage context but gives no when-not conditions, prerequisites, or alternatives. An agent can infer the domain but gets no routing guidance relative to dice-roller or quiz.

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

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

With no annotations provided, the description carries the full burden, and it does disclose meaningful behavior: no server computation, an interactive tap-when-green loop, and a millisecond result. It omits secondary traits such as whether the locale affects the card UI or whether results are persisted, keeping it short of 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 tight sentences, zero filler, and the core behavior and output are front-loaded in the first clause. Every phrase 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?

There is no output schema and only one optional parameter, so the description's coverage of the interaction and the millisecond result is nearly sufficient. The only real gap is the unexplained locale parameter, which is minor for a zero-required-parameter UI card.

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

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

The single locale parameter has 0% schema description coverage and is never mentioned in the description, so the agent gets no explanation of what the en/zh enum actually controls. The schema's enum and default are self-explanatory enough to avoid a 1, but the description adds nothing here.

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 artifact (an interactive reaction-time test card) and states exactly what it measures (milliseconds), so an agent immediately knows what the tool produces. It does not, however, differentiate itself from similar interactive-card siblings like typing-test or quiz, so it lands just short of a 5.

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 only implied: the tool is for running a client-side reaction test. There is no statement of when to prefer it over siblings such as typing-test, nor any exclusions or preconditions, so the agent must infer the context.

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

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

With no annotations, the description carries the full burden. It does disclose the response content ('Returns the resistance and tolerance'), which is genuinely useful, but it says nothing about band-count constraints (3/4/5/6 bands), how invalid color ids are handled, or whether band order is positional.

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 with no waste, and the core action is front-loaded before the input/return details. Efficient, though the terse 'Input:'/'Returns:' fragments read more like notes than structured guidance.

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

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

There is no output schema and no annotations, so the description is the only source of behavioral detail. It covers the basic contract (input colors, output resistance + tolerance) but omits the constraints that matter most for a decoder, such as accepted band counts, positional ordering rules, and invalid-input behavior.

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 does add real value for `bands` by naming the value domain (color ids) and giving a concrete ordered example, but the `locale` parameter is completely undocumented in both the schema and the description.

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 and resource ('Decode a resistor color code'), which is unambiguous and distinct from color-domain siblings like color-palette or color-studio. However, it never explicitly contrasts itself against those siblings, so an agent must infer the distinction from the domain wording alone.

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 use this tool, when not to, or what alternatives exist. The example input hints at usage but is presented as a parameter illustration rather than selection guidance.

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

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

With no annotations provided, the description carries the full burden and does disclose behavior: it performs a network fetch for the `url` input, and it enumerates what is returned (syntax validity, JSON-LD signals, node count, top-level keys, parsed structure). It does not mention size limits, fetch failure/timeout behavior, or that the operation is non-mutating, so it falls short of full 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?

Three compact sentences, front-loaded with the core action, followed by inputs, then outputs, then the usage trigger. Every sentence carries information and nothing is padded.

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 compensates by summarizing the return payload, and it covers both input paths. It omits edge-case behavior (neither input supplied, both supplied, fetch failures), which matters for a zero-required-parameter 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 all three parameters are already documented in the schema, giving a baseline of 3. The description restates the two input modes (`json` string vs `url` to fetch) but omits the `locale` parameter entirely and does not clarify precedence if both inputs are supplied.

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

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

The description opens with a specific verb triple (parse, validate, summarize) applied to a well-scoped resource (structured JSON or JSON-LD document). No sibling tool overlaps with this function, so an agent can route to it unambiguously.

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 names the concrete trigger condition: 'when a user pastes structured data / schema.org markup and wants it checked, explained or cleaned up.' That is clear context with no ambiguity, but it offers no explicit exclusions or alternative tools for related tasks (e.g. jwt-decoder for tokens).

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 the return fields (count, mean, std, histogram), but says nothing about edge cases like empty input, non-numeric values, or whether a histogram bin parameter exists, leaving behavioral gaps for a compute 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?

Four short sentences, front-loaded with purpose, then input, output, and usage. No filler; each sentence carries distinct information, though the output enumeration makes it slightly long.

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 or annotations exist, so the description compensates by listing return values and input formats. It is nearly complete for a simple compute tool, with the main gap being the unexplained `locale` parameter and no error-handling notes.

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 50%. The description does add value by clarifying that `data` may be an array OR a space/comma-separated string, which the string-typed schema does not convey. However, the `locale` enum parameter is undocumented in both schema and description.

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 ('describe') and resource ('data set') and then enumerates the exact outputs (count, sum, mean, median, std, min, max, quartiles, histogram). That makes the tool unambiguous, though it doesn't need to differentiate from the unrelated sibling utilities.

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 gives a trigger condition: 'Use when a user wants statistics on numbers.' No alternatives or exclusions are named, but no sibling overlaps in function, so this is adequate context without a routing problem.

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 does disclose the return shape (diff lines tagged same/add/del plus counts), which is genuinely useful for a pure-computation tool. However it omits any limits (max text size, line count), and says nothing about what the `locale` option changes, leaving gaps.

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 short sentences with no waste; the core purpose is front-loaded and the input/output facts follow immediately.

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 describing the return value here is the right call and it is done adequately. But an unexplained third parameter and absent size/limit guidance leave the agent with open questions for anything beyond the trivial case.

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 should compensate. It names `a` and `b` but only restates their obvious role as the two texts, and it completely ignores the `locale` parameter, which has an enum and a default and is the one parameter whose meaning is non-obvious.

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 ('Compute') and resource ('line diff') plus the scope ('between two texts'). No sibling tool overlaps with diffing, so no differentiation is needed and the purpose is unambiguous.

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

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

The description never says when to use this tool versus an alternative, nor any precondition such as input size or encoding expectations. Usage is only inferable from the name.

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 behavioral burden. It discloses the inputs, their defaults, and that the tool 'Returns the current code', which implies a time-rotating, side-effect-free computation. It omits important traits such as whether the code expires with the period, whether any credentials or network are required, and how the `locale` argument affects the result.

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 short sentences with the core action front-loaded and no filler. The input list partly restates the schema, but with 0% schema coverage that restatement is justified rather than 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?

For a 4-parameter tool with no annotations and no output schema, this covers the essentials (input, defaults, return) but leaves `locale` unexplained and gives no detail on the code's time-based validity. It is adequate but has clear 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 0%, so the description has to compensate. It documents `secret`, `digits` (default 6) and `period` (default 30), which is useful given the bare schema, but it silently drops the `locale` parameter and its en/zh enum, leaving that argument entirely 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?

The description names a specific verb and resource ('Generate a TOTP code from a Base32 secret'), so the agent knows exactly what it produces. No sibling tool overlaps with TOTP generation, so sibling differentiation is not needed, but the definition never positions itself against the utility siblings either.

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 to verify 2FA setup' gives one concrete scenario, which is better than nothing, but there are no when-not conditions and no alternatives offered. Usage is implied rather than scoped.

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. It discloses the return shape (equation and features) but does not state determinism, side effects, error behavior, or the effect of the locale parameter on rendered output.

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 well-structured paragraph that front-loads purpose, then inputs, returns, and use case. The input list partly repeats schema descriptions, but it remains efficient and readable.

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 computational tool with no output schema, the description adequately explains the return values and teaching context. It misses the locale parameter and does not provide sibling routing, but those gaps are minor relative to the schema coverage.

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 adds value by mapping parameters into the formula y = A·f(ωx+φ)+k and explaining what features are derived, though it omits the locale parameter present 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 states a specific resource (trigonometric functions and the unit circle) and explains what the tool returns (equation and features). It is clear enough for an agent to distinguish from generic graph tools, but it does not explicitly differentiate itself from siblings like function-grapher or geometry-lab.

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 explicit intended use: 'Use this for teaching trigonometry, periodic functions and graph transformations.' This is clear context for when to select it, though it names no alternatives or 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?

With no annotations, the description carries the full burden, and it does disclose the interaction model (user types a sentence) and the observable outcome (WPM and accuracy reported). It does not cover whether state persists, whether results are stored, or how the card is triggered, but for a lightweight self-contained card this is adequate 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?

Two compact sentences, front-loaded with the tool's identity before the mechanics. Nothing is wasted, though the second sentence could have carried the locale information at no cost to length.

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

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

The description covers the interaction and return values, which is the right emphasis given there is no output schema. However, with no annotations and an undocumented locale parameter that changes the test's language, it falls short of being fully complete for invocation.

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

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

Schema description coverage is 0% and the description never mentions the sole parameter, locale. The enum values en/zh are self-explanatory in the schema, but the agent gets no explanation of what the locale controls (presumably the language of the prompt sentence), so the description does not 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?

The description names a specific verb+resource combination ('interactive typing-speed test card') and states what it produces (WPM and accuracy), so an agent can tell it apart from neighbors like reaction-test or quiz. It stops short of explicitly contrasting itself with those siblings, but the purpose is unambiguous.

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

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

There is no statement of when to use this tool versus the many other interactive test cards in the sibling list (reaction-test, quiz, password-strength). Usage is only implied by the phrase 'interactive typing-speed test card,' with no prerequisites, exclusions, or alternatives named.

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

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

With no annotations present, the description carries the full disclosure burden. It implies a pure, side-effect-free computation and discloses nothing about error behavior, matching constraints, or return format. For a stateless calculator the risk is low, but the disclosure is only minimally adequate.

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

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

Front-loaded with the core action, then parameters, then examples, then a usage line — tight and scannable. The closing 'Use whenever...' sentence is close to filler but does carry routing 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?

No output schema and no annotations, so the description is the only source of behavioral information. It never explains that `from`/`to` must belong to the declared `category`, what happens on a mismatched or unknown unit id, or what the call returns. That constraint is the main way an agent could call this tool incorrectly.

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 four documented parameters are already explained in the schema; the description largely restates them and repeats the category enum. It omits the fifth parameter, `locale`, entirely. The conversion examples (km→mi, c→f, mb→gib) add modest value by showing unit-id format.

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 ('Convert a numeric value between units') and immediately grounds it with category enumeration and concrete examples (km→mi, c→f, mb→gib). No sibling tool in the list competes with it, so an agent can identify it instantly.

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 whenever a user needs a unit conversion' gives a clear positive trigger condition. It offers no exclusions or alternatives, but none of the sibling utilities overlap with this capability, so there is little to disambiguate against.

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

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

No annotations are provided, so the description carries the full burden. It discloses that this is a read-only estimator and spells out what is produced (memory breakdown, recommended GPU configuration, vLLM/Ollama launch commands). For a pure computation tool with no side effects, this covers the relevant behavioral surface, though it says nothing about determinism or limits.

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

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

Front-loaded with the verb and resource, then inputs, outputs, and usage in three tight sentences. The inputs list partially duplicates the schema, which is a minor redundancy, but nothing is padded and the structure is easy to scan.

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

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

With no output schema, the description correctly explains the return shape (breakdown, GPU recommendation, launch commands). For a stateless calculator with fully covered parameters, an agent has everything needed to invoke it and interpret 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 description coverage is 100%, so the schema already documents all seven parameters and their defaults/enums; baseline is 3. The description restates five of them (params, precision, context length, batch size, KV precision) but omits tensorParallel and locale, adding no syntax or format detail 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 (Estimate) and resource (GPU VRAM in GB) with the exact scope: serving a large language model. It is immediately distinguishable from every sibling tool, none of which touch GPU memory estimation.

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 names the triggering situations: 'when a user asks how much GPU memory a model needs or which GPU to buy/rent.' That is a clear usage context. It does not name a when-not or an alternative, but no competing sibling exists, so the only missing piece is theoretical.

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

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

With no annotations, the description carries the full burden; it discloses that the tool returns each city/timezone with current time and date, which is genuinely useful. However, it does not say whether supplying `zones` replaces the default city list or merely narrows it (the word 'limits' is ambiguous), nor how unknown timezone ids are handled. For a read-only informational tool this is adequate but incomplete.

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 short sentences, front-loaded with the core purpose, then the parameter note, then the return shape, then the usage trigger. 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?

With no output schema, the description usefully states what is returned (city/timezone with current time and date), and usage is covered. The only real hole is the undocumented `locale` parameter, a minor omission for a two-parameter, zero-required 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 50%: `zones` is described in both schema and description (the description clarifies it 'limits the list', slightly beyond the schema's terse 'Optional timezone ids'), while `locale` — including its enum of en/zh — is undocumented anywhere. The description adds modest value but does not compensate for the locale 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 and resource ('Show the current time in major cities') and adds scope detail about the optional zones filter. It is clear what the tool does, though the sibling list contains no directly competing time tool to differentiate against, so no sibling contrast is offered.

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 final sentence gives a concrete trigger condition: 'Use when a user asks the time somewhere.' It does not name exclusions or alternatives, but none of the siblings (chrono-energy, cron-debugger) plausibly overlap, so the guidance is sufficient in context.

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