Agent Tools MCP

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

Annotations already declare the safety profile (readOnly, idempotent, non-destructive, closed-world). The description adds meaningful context beyond them by clarifying the return format ('Returns SVG markup, not a photorealistic likeness'), which sets correct output expectations. It doesn't discuss the deterministic-seed behavior, but that is documented in the schema.

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 no waste; purpose comes first, then usage, then the output-format caveat. Every sentence earns its place.

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

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

No output schema exists, but the description compensates by stating the tool returns SVG markup. With full parameter coverage and complete annotations, an agent has everything needed. Only minor gaps (e.g., seed determinism) remain, and those are covered by the schema.

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

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

Schema coverage is 100% with a documented enum and per-field descriptions, so the schema carries parameter meaning fully. The description adds no syntax or format detail beyond it, so the baseline 3 applies.

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

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

States a specific verb+resource ('Create an SVG placeholder profile icon') and immediately scopes the output type. Distinguishable from sibling generators like generate-color or generate-hash by naming the artifact produced.

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

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

Provides clear context ('Use for synthetic avatars in demos and UI prototypes'), which tells the agent when the tool is appropriate. It does not name alternatives or explicit exclusions, but the sibling set is a homogeneous generator family and none overlaps here.

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

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

Annotations already declare readOnlyHint, idempotentHint, non-destructive, and closed-world, so safety is largely covered. The description adds value beyond them by disclosing the return shape ({number, brand, expiry, cvc}) and the important caveat that values are synthetic and not issued credentials, which an agent must not treat as real payment data.

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 purpose, then usage, then return/safety caveat. Every sentence carries distinct information with no redundancy.

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

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

With no output schema, the description steps in to describe the returned object and its synthetic nature, and the annotations cover the safety profile. Nothing essential for correct invocation 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% and both parameters (seed, brand) are fully documented in-schema, including the enum values and the determinism meaning of seed. The description adds nothing about parameters, so the baseline 3 is appropriate.

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

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

States a specific verb and resource ('Generate a synthetic payment-card fixture') and immediately narrows scope to Luhn-valid card numbers for payment-form UI tests. Despite a large sibling set of generate-* tools, the resource noun (payment-card) makes the distinction unambiguous without naming an alternative.

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

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

Gives a clear use case ('payment-form UI tests requiring a Luhn-valid card number') and implicitly warns that this is for fixtures, not real credentials. It stops short of naming when-not-to-use or pointing to a sibling (e.g., generate-ssn or generate-token), so no exclusion guidance is present.

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

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

Annotations already establish the safe read-only, idempotent, non-destructive profile. The description adds genuinely new behavioral context: the return shape and the caveat that the text color is heuristic rather than a WCAG contrast check, which prevents a downstream consumer from trusting it for accessibility.

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: purpose first, then usage/defaults/return caveat. No filler and nothing important buried.

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

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

With no output schema, the description fills that gap by naming the returned object keys and flagging the heuristic text-color caveat; combined with 100% parameter coverage, an agent has everything needed to call and interpret the tool.

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

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

Schema coverage is 100%, so the baseline is 3; the description earns an extra point by supplying the default values (random base, triadic, count 5, hex) that the schema itself does not encode.

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 ('Generate a palette') plus the inputs that drive it (base color, harmony scheme), which cleanly separates it from siblings like generate-hash or generate-lorem.

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 design prototypes' gives a clear usage context, and the stated defaults (random base, triadic scheme, five hex colors) tell the agent what happens when it passes nothing. It stops short of naming when-not to use it or pointing at any alternative tool.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so safety is covered. The description adds real behavioral context beyond that: the hard cap of eight records and the fact that no database is accessed. It doesn't discuss seed reproducibility or error behavior, but the added disclosure is meaningful.

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 with no filler; the output-format clause is front-loaded, followed by the routing guidance and the record cap. Every clause earns its place.

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

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

For a 4-parameter, zero-required tool with a nested schema object and no output schema, the description covers output shape (at most eight records), formats, and sibling routing. The nested field-specification object is left to the schema, which is reasonable, though a note on how seed affects output would complete 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 100% with 4 documented parameters (seed, count, format, schema), including the enum and the 1-8 bound, so the schema carries the parameter burden. The description only echoes the format list and the count ceiling, adding no syntax or semantics beyond what is already structured.

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 (generate synthetic rows) plus the concrete output formats (JSON, JSONL, CSV), so an agent knows exactly what the tool produces. It explicitly distinguishes itself from the sibling generate-fake-data, which shares the 'generate' prefix in this crowded family.

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 a positive use case (data import/export tests) and names the alternative tool with the condition that selects it (generate-fake-data for preset people or company fixtures). This is explicit when-to-use plus when-to-use-something-else, which is exactly what the routing decision requires.

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

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

Annotations already declare readOnly, idempotent, non-destructive, closed-world behavior, so the safety profile is covered. The description adds a genuinely useful caveat that output values are not verified identities, a trust/quality signal not present in structured fields. It does not mention the deterministic seed behavior beyond what the schema already states.

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 core action and followed immediately by routing and a caveat. Every clause earns its place with no redundancy.

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

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

A simple, read-only, single-required-parameter tool with a fully documented schema and no output schema; the description covers purpose, alternative, and a data-trust caveat. It stops short of describing the shape of returned records, which is the only remaining gap for an agent consuming the output.

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 kind, seed, and count are fully documented in the schema, establishing the baseline of 3. The description's 'preset records' phrasing loosely implies the kind values are fixed fixtures, but it adds no syntax or semantics (e.g., seed determinism, the eight-record cap) 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 ('Create') and concrete resources ('fictional users, companies, addresses or rows') that map directly to the kind enum. It also names the sibling tool it is not (generate-dataset for custom fields), so an agent can distinguish it without opening either 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 both the use case ('seed demos with preset records') and the explicit alternative ('use generate-dataset for custom fields'), which is the exact selection condition an agent needs. Nothing is left to inference about when to pick this tool over its 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?

Annotations already declare read-only, idempotent, non-destructive, closed-world behavior. The description adds value beyond them by disclosing the output shape (a hex digest) and misuse boundaries (not for password storage or key derivation, no secrets as input), which the annotations do not imply. It does not discuss limits such as the 4096-char cap, but that is already in the schema.

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: the purpose and algorithm options come first, then routing to the alternative, then the return format and prohibitions. Every clause earns its place.

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

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

For a two-parameter, annotation-covered tool with no output schema, the description supplies everything an agent needs: what it does, when to prefer the sibling, what it returns, and the safety caveats around secret content. Nothing material 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 both parameters (algo enum, text) are fully documented in structured data. The description names the same algorithms already enumerated in the schema and reinforces the non-secret input intent, but adds little parameter meaning beyond that. Baseline 3 applies when the schema carries the load.

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 SHA-256 or legacy MD5 text digests') and explicitly distinguishes itself from the sibling generate-token, which creates new IDs rather than deriving digests. An agent can separate this from the other generate-* tools 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?

Gives positive guidance ('use for non-secret content fingerprints'), names the competing sibling and what it is for instead, and adds a negative constraint ('unsuitable for password storage or key derivation'). Both when-to-use and when-not-to-use are covered explicitly.

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

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

Annotations already declare readOnlyHint, idempotentHint, non-destructive and openWorldHint=false, so the safety and determinism profile is covered. The description adds one genuinely new fact — the copy is synthetic rather than sourced editorial content — which reinforces the closed-world hint, but says nothing further about determinism via seed or about output length behavior.

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

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

Three short sentences, each carrying distinct information: what it does, when to use it, what it returns. The core action is front-loaded and there is no filler.

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

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

A zero-required-parameter, single-purpose generator with a fully described schema and no output schema. Everything an agent needs to call it correctly — purpose, use case, output nature, unit and count options — is present.

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

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

Schema description coverage is 100%, so seed, count (1-8, default 3) and the units enum are fully documented in the schema. The description's mention of "words, sentences or paragraphs" merely echoes the enum and adds no syntax or semantics of its own. Baseline 3 is correct.

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 ("Generate lorem ipsum placeholder copy") and adds a scoping qualifier that separates it from the other generate-* siblings: it produces filler text, not real data objects. An agent can pick this over generate-fake-data or generate-prompt from the sentence 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?

"Use for mock layouts needing filler words, sentences or paragraphs" gives a concrete use context and the range of output units. There is no statement of when not to use it or a named alternative, so it stops 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?

Annotations already establish readOnly/idempotent/non-destructive, so the bar is lower; the description adds real security-relevant context the annotations do not: seeded values are predictable and visible to MCP clients, and output is not vault-grade. It stops short of describing return format or whether outputs are stored, but for a safe read-only generator this is solid added value.

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

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

Two tight sentences with zero filler; the core purpose and the sibling routing are front-loaded and the safety caveat is the final clause.

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

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

No output schema exists, yet the definition adequately covers purpose, usage, sibling routing, and the key security caveat. The only minor gap is that nothing describes the response shape, which is low-stakes for a trivial generator.

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

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

Schema coverage is 100%, so the schema already documents seed, length, and symbols including the determinism caveat on seed. The description's reference to 'seeded' output reinforces the seed parameter but adds no syntax or format detail beyond the schema, so the baseline 3 applies.

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

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

States a specific verb+resource ('Generate random or seeded test passwords') and immediately differentiates from the closest sibling by name ('use generate-token for identifiers'). An agent can select this tool over generate-token without opening either 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 names the appropriate use case ('demo login fields') and the alternative tool with the condition that selects it ('generate-token for identifiers'). It also supplies an exclusions-style warning that this is not a secure credential vault.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), so the bar is lower. The description adds real behavioral value beyond them: the return shape ('array of fictional (AAA) 555-01XX numbers'), the guarantee that these are fictional-only, and the city/state coupling rule.

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: purpose first, then usage/constraint, then return contract. No filler, and the most important routing information is front-loaded.

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

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

With no output schema, the description compensates by stating the return format and the fictional-number guarantee. Combined with full schema coverage and annotations covering safety, an agent has everything needed 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 coverage is 100%, so baseline is 3, but the description adds meaning beyond the schema by explaining that 'city selects a local area-code pool' and must match state — the schema only says 'must match state if given' without describing the area-code mechanism.

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 ('Generate fictional US-format phone numbers') and scopes it to a fictional 555-01XX range, which cleanly separates it from siblings like generate-ssn or generate-card-number. The 'no subscriber lookup' clause further disambiguates it from any real lookup 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 for US demo phone fields' gives a clear intended context, and the city/state matching rule signals a precondition. However, it names no alternative tool and states no explicit when-not condition, so it stops short of a full routing instruction.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds real behavioral context beyond that: missing variables are replaced with empty text (a silent-failure mode worth knowing), the return is a prompt string, and code/image modes add framing.

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, each earning its place: purpose, placeholder syntax plus fallback behavior, then return semantics and mode framing. Front-loaded with the core action and 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?

With no output schema, the description correctly states what comes back ('a prompt string without invoking a model'), and it covers the mode enum and variable substitution behavior. The only gap is the deterministic seed helper, which the schema does document but the description never ties into the rendering 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 the baseline is 3. The description reinforces the {name} → vars.name mapping and the missing-variable behavior, but adds little syntax detail the schema does not already carry, and it never mentions the seed parameter's {{RAND_INT:min,max}} helper.

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 and resource ('Fill a prompt template with supplied variables') and immediately clarifies the non-obvious boundary that it does not invoke a model. That distinction separates it cleanly from the generate-* siblings, which all produce data rather than rendered template text.

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 implicitly scopes usage by stating the tool only renders a prompt string and never calls a model, which tells the agent this is a pre-processing step rather than a generation step. However, it names no alternative and gives no explicit when-to-use or when-not-to-use condition.

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

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

Annotations already declare readOnly, idempotent, and non-destructive behavior, so the safety profile is covered. The description adds value beyond that by flagging 'Unicode-aware' normalization and advising verification of output before permanent use, hinting the result may not match naive expectations.

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 filler; the core purpose leads. Slightly terse on the return behavior, but every sentence earns its place.

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

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

For a simple read-only generator with full schema coverage and no output schema, the description covers purpose, usage, and a verification caveat. The absence of an output schema means return values are undocumented, but the 'inspect output' advice partially compensates.

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

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

Schema description coverage is 100%, with both 'text' and 'maxLength' fully documented in the schema. The description adds only the general 'Unicode-aware' framing and no syntax or format detail for the parameters, so baseline 3 is appropriate.

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

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

States a specific verb (convert) and resource (title → Unicode-aware URL slug), making the operation unambiguous. No sibling produces slugs, so it is naturally distinct, but the description does not explicitly name or contrast 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?

Gives clear context: 'Use when forming new path segments from headings,' and adds a precaution about inspecting output before publishing permanent URLs. There are no explicit when-not conditions or named alternatives, but for a single-purpose generator the guidance 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?

Annotations already declare readOnly, idempotent, closed-world and non-destructive, so the safety profile is covered. The description adds real value beyond that: it discloses the return-shape polymorphism ('string for count=1, otherwise an array') and warns that structural validity does not confirm issuance. It does not mention determinism behavior when seed is supplied, which would have made this 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?

Three short sentences, zero filler, with purpose front-loaded and the sibling routing and return-shape caveats following in priority order. Every sentence earns its place.

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

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

There is no output schema, so the description correctly compensates by stating the return shape (string vs array). Combined with the annotations covering safety and the fully documented schema, an agent has everything needed 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 description coverage is 100%, so all four parameters (seed, count, valid, formatted) are already documented in the schema, and the description adds no parameter-level syntax or format detail. It only indirectly touches count via the return-shape note. 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 and resource ('Generate fictional US SSN-style test identifiers') that is unambiguous and immediately distinguishable from siblings like generate-fake-data and generate-phone-number. The scope is narrowed to test fixtures rather than real data, which an agent can act on 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 names the alternative ('use generate-fake-data for mixed-record fixtures') and the condition that selects it, giving both when-to-use and when-to-use-something-else. Nothing 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?

Annotations already declare readOnly/idempotent/non-destructive, so the safety profile is covered. The description adds genuinely new context beyond the annotations: seeded output is deterministic and therefore unsuitable for authentication credentials, which is exactly the caveat an agent needs before using this for a security-sensitive purpose.

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: purpose first, sibling routing second, safety caveat last. No filler, everything front-loaded.

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

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

No output schema exists, but the return value is self-evident from the tool's nature and the required 'type' parameter. Annotations and description together cover safety, determinism and usage; only return/pagination detail is absent, which is negligible here.

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 (including the enum values and the seed's intended use) are already documented in the schema. The description adds only an indirect nod to the seed via the predictability warning, 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 ('Generate token strings or UUIDs') and immediately distinguishes itself from the nearest sibling by naming generate-password. An agent can tell what this produces 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?

Gives an explicit use case ('test identifiers') and routes the agent to an alternative ('use generate-password for password fixtures'). It stops short of stating exclusions or when this tool is inappropriate beyond the credential warning, but the routing guidance is clear.

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

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

With annotations already covering read-only, non-destructive, idempotent behavior, the description adds useful detail: the return shape {ok, normalized?, brand?, last4?, issues} and the important non-goal that this is not an authorization or fraud check. It also reinforces the synthetic-number constraint.

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 with no waste. The core purpose is front-loaded, followed by usage context and return/non-goal information.

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

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

For a single-parameter validator with no output schema, the description supplies the missing return shape and clarifies the scope and limitations. Annotations cover safety, and the input schema covers the parameter, so nothing essential 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 100%, so baseline is 3, but the description adds meaning beyond the schema by specifying that the input number is checked for brand, length, and Luhn checksum. It does not add format syntax or examples, but it clarifies what the examination actually does.

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 (Check) and precise resource scope: payment-card brand, length, and Luhn checksum. This clearly separates it from the many is-*-safe validators and the generate-* tools in the sibling list.

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 states a concrete use case (synthetic card numbers in payment-form tests) and an explicit non-goal (not payment authorization or fraud check). It does not name an alternative tool for generating test numbers, but the positive and negative usage boundaries are clear.

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

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

Annotations already declare the safe, read-only, idempotent, closed-world profile, so the safety burden is lifted. The description adds real value beyond that: it discloses the return type (true or false) and the important scope boundary that deliverability/mailbox existence are not verified.

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 purpose, then usage, then return/boundary behavior. No filler, no repetition of the tool title.

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

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

For a one-parameter boolean validator with no output schema, the description covers purpose, usage context, return values, and the key limitation. An agent has everything needed to call it correctly and interpret the result.

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 single parameter already documents the format, an example, and the ASCII-only constraint. The description's 'conservative ASCII' phrasing reinforces but does not extend 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 (Check) and resource (email address syntax) with a scoping qualifier ('conservative ASCII') that defines the validator's strictness. The resource name cleanly distinguishes it from the many sibling validators like is-url-safe, is-uuid-safe, and is-card-safe.

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 intended contexts: rejecting malformed addresses in forms and test fixtures. It also carves out what it is not for ('does not check mailbox existence or deliverability'), which pre-empts a common mis-invocation, though it names no alternative sibling tool.

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

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

Annotations already declare read-only, idempotent, non-destructive, closed-world behavior, so the safety profile is covered. The description adds genuinely useful context beyond that: validation is offline against a bundled registry, and it explicitly disclaims account ownership or transferability verification.

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

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

Three short sentences, zero filler: what it checks first, then usage guidance, then return shape and limitations. Everything is front-loaded and each sentence earns its place.

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

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

Despite having no output schema, the description discloses the return shape {ok, normalized?, issues} and bounds the tool's guarantees. For a single-parameter validator with full annotation coverage, nothing an agent needs to invoke it correctly 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?

Only one parameter with 100% schema description coverage, including the spaces-tolerance and privacy note, so the schema already carries the semantics. The description adds nothing about input format beyond what the schema states, making the baseline 3 correct.

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 (check) and precise resource scope: IBAN country rules, length and checksum against a bundled registry. It is immediately distinguishable from sibling validators like is-card-safe or is-vat-safe by naming exactly which standard it enforces.

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 says to use it for screening public or synthetic IBANs in test data, which gives a clear triggering context. It also states a scope exclusion (no ownership or transferability verification) but does not name a sibling alternative or a when-not-to-use path.

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

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

Annotations already declare readOnly/idempotent/non-destructive/openWorld=false, so the safety profile is covered. The description adds genuinely useful contract detail the annotations lack: the return shape {ok, version, issues} and that version is 4, 6 or null — especially valuable with no output schema.

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 action, then scope, then return contract. Every clause carries information; nothing is padding.

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 single-parameter, no-output-schema validator with full annotation coverage, the description supplies everything an agent needs: purpose, exclusions, and return shape. Nothing required to invoke or interpret it correctly 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 100% with one documented param, so baseline is 3. The description's 'literal-address syntax' wording adds meaning beyond the schema by implying no hostnames, ports, or CIDR notation are accepted, tightening the expected input 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 — 'Check IPv4 or IPv6 literal-address syntax' — which is unambiguous and self-distinguishing from the is-*-safe sibling family (each validates a different literal type). An agent can tell exactly what class of input this accepts 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 to screen candidate IP strings') and gives a concrete exclusion ('not test reachability or geolocation'), which prevents a common misuse. It stops short of naming an alternative tool, but no sibling validator competes for this input type.

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

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

Annotations declare safe/read-only/idempotent/closed-world, so the safety profile is covered. The description adds real semantic context beyond that: it clarifies the accepted format family (Gregorian, leap-day aware) and states the boolean return, which matters because no output schema exists.

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 usage constraint, then return value. No padding or 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?

With no output schema, the description correctly compensates by stating the boolean return contract. Combined with annotations covering safety and a fully documented single parameter, an agent has everything needed 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% and the schema already specifies the YYYY-MM-DD format with an example (2024-02-29). The description's 'including leap days' is minor added value over the schema's example, so the baseline 3 is correct.

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

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

States a precise verb+resource ('Check Gregorian YYYY-MM-DD calendar dates') and adds scope qualifiers ('including leap days') that tell the agent exactly what is and isn't validated. The distinction from sibling is-* validators is self-evident from the date-specific scope.

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 date-only form fields, not timestamps or timezone offsets' gives an explicit when-to-use and an explicit when-not-to-use. It stops short of naming an alternative tool for the timestamp case, which keeps it from a full 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?

Annotations already cover safety (readOnly, idempotent, non-destructive), but the description adds real value: parsing runs without execution, limits are enforced on depth/keys/size, and the returned value is conditional on validity. The specific limit thresholds are not quantified, which keeps this 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?

Three short sentences, front-loaded with the action, then routing, then return shape. No filler or redundant restatement of the name.

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

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

With no output schema, the description compensates by naming the return fields ({ok, issues, bytes, depth, keys, value?}) and the condition under which value appears. Combined with the routing hint, an agent has everything needed to call and interpret this 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% for the single 'json' parameter, so the baseline is 3. The description's mention of bounded depth, key counts and input size mirrors what the schema already documents rather than adding syntax or format guidance.

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

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

Specific verb+resource with scope: parse/screen JSON under bounded depth, key counts and input size. It explicitly names the sibling it is not (optimize-dataset for JSONL/CSV), so an agent can route correctly without opening either 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?

States when to use it ('screen JSON without execution') and names the concrete alternative plus its condition ('use optimize-dataset for JSONL or CSV cleanup'). Nothing is left to inference about tool 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?

Annotations already cover the safety profile (readOnlyHint, idempotentHint, destructiveHint=false, closed-world), so the bar is lower. The description still adds real value by disclosing a behavioral limit — 'no breach-database lookup' — and enumerating the return shape, which the annotations do not convey.

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

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

Three short sentences, front-loaded with purpose, then the safety constraint, then the return contract. Every clause carries information; nothing is redundant padding.

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 compensates by listing the returned fields ({ok, score, entropyBits, length, sets, reasons, suggestions}) and explicitly scoping out breach lookup. For a one-parameter read-only tool this is complete enough to call 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 the single 'password' parameter is already documented in the schema as a fictitious test password. The description's dummy-password warning reinforces but does not extend the schema, so the baseline of 3 applies.

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

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

States a specific verb and resource ('Evaluate password strength') plus the method ('local heuristics'), which cleanly separates it from the sibling generator (generate-password) and the other validators (is-card-safe, is-email-safe). An agent can identify the operation 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?

Gives an explicit use condition: 'Use only with dummy passwords when testing password policies.' That is a genuine when-to-use constraint, though it names no alternative tool or exclusion beyond the dummy-password rule (e.g., it does not point to generate-password for creating test inputs).

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

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

Annotations already declare readOnly/idempotent/non-destructive and the closed-world hint, so the safety profile is covered. The description adds genuinely new context beyond the annotations: it returns a boolean rather than the normalized number, and it explicitly excludes subscriber or reachability checks, which prevents an agent from over-trusting a true 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?

Three tight sentences: what it does, when to use it, and what it returns/what it does not cover. The most decision-relevant information (the check itself) is front-loaded 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 must carry the return-value burden, and it does by stating the boolean result and that the normalized number is not returned. For a one-parameter, annotated validator, nothing an agent needs to call it correctly 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 100% for the single 'phone' parameter, so the baseline is 3. The description goes beyond the schema example by specifying that spaces and 00-prefixed forms are accepted after local normalization, which tells the agent it can pass loosely formatted input rather than only canonical '+66812345678' strings.

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 ('Check ... syntax') and resource ('phone number ... against E.164'), and the 'is-' prefix plus the explicit E.164 scope cleanly separates it from the generate-phone-number generator and the other is-*-safe validators. The added scope note ('after local normalization') makes the operation 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?

It states the use case directly: testing international number formats, including spaces or 00 prefixes, and clarifies it is not a subscriber/reachability check. It does not name a specific sibling alternative, but the boundary against the generator and the safety-check family is clear from how the use case is framed.

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

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

Annotations already establish readOnly, idempotent, non-destructive. The description adds genuinely useful behavior beyond them: it returns a boolean and performs no network access, which matters because the tool name suggests a safety assessment it explicitly does not perform.

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, front-loaded with the core action, then usage, then the most important caveat. No filler and nothing buried.

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

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

For a single-parameter boolean validator with no output schema, the description supplies the return type and the key limitation (no visitation, no safety judgment), which is everything an agent needs to call and interpret 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?

With 1 parameter and 100% schema description coverage, the schema already documents the url string and its scheme restriction. The description's "absolute HTTP or HTTPS URL syntax" largely restates that constraint rather than adding format or length guidance.

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 (check) and resource (absolute HTTP/HTTPS URL syntax), which cleanly separates it from the many is-*-safe siblings that validate other formats. The closing clause explicitly disclaims site-safety assessment, preventing the 'safe' in the name from being misread.

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 screen links before display or storage" gives a concrete usage context, and "does not ... assess the site's safety" implicitly rules out a security-check interpretation. However, it does not name alternative tools or state when validation is unnecessary.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), but the description adds real behavioral scope beyond them: it discloses the return shape ({ok, normalized?, type, issues}) and, critically, that it does not verify IRS issuance or identity. That negative claim prevents a common misinterpretation of the tool's guarantees.

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

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

Three short sentences, zero filler. Purpose comes first, the safety constraint second, and the return contract plus scope limitation last — an appropriate front-loaded ordering for a validation tool.

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 supplies the response shape itself, states the input safety constraint, and bounds what the tool does and does not prove. Nothing an agent needs to invoke or interpret this tool correctly 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 single 'tin' parameter is already documented and baseline would be 3. The description adds marginal value by enumerating the accepted identifier families (EIN/SSN/ITIN) and reinforcing the synthetic-only constraint, telling the agent what kinds of strings are valid.

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

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

States a precise verb (check) plus the exact resource (synthetic US EIN, SSN, or ITIN formats), and explicitly frames itself as a format validator rather than an identity/issuance verifier. An agent can distinguish it from generate-ssn and the is-*-safe siblings 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?

Gives clear context ('use with tax-ID input fixtures') and an explicit when-not ('never real personal identifiers'), which is the key safety boundary for this tool. It stops short of naming alternatives (e.g., generate-ssn for producing fixtures), so it is strong context but not 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?

Annotations already declare readOnly/idempotent/non-destructive/closed-world, so the safety profile is covered. The description adds value beyond them by disclosing the return shape ('Returns true or false') and the scope limits ('does not check uniqueness or resource existence'), which prevents misuse as an existence probe.

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

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

Two tight sentences with no filler: the core action and scope come first, then the sibling routing, then the return/limits caveat. 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?

No output schema exists, but the description states the boolean return, and it covers the primary misuse case (uniqueness/existence) for a simple 2-parameter validator. Nothing an agent needs to call this correctly 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 both `uuid` and `version` are already documented, including the 1-8 range and omit-for-any behavior. The description's phrase 'optional RFC variant/version' adds only a light conceptual hint (variant) over the schema, so the baseline of 3 applies.

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

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

States a specific verb and resource ('Check canonical UUID syntax') plus scope qualifiers ('optional RFC variant/version'), and contrasts with the generate-token sibling. An agent can distinguish it from the many is-*-safe siblings purely from the name plus this sentence.

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 says 'Use to validate UUIDs; use generate-token to create them', naming the alternative tool for the inverse operation. It also sets a boundary by ruling out uniqueness and resource-existence checks, though it gives no guidance on when a different is-*-safe validator would be preferred.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, no open world), and the description adds meaningful behavior beyond that: it enumerates the return shape {ok, country?, normalized?, issues} and explicitly disclaims VIES lookup and active-registration checks, aligning with openWorldHint=false. This tells the agent exactly what the tool will and will not verify.

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, front-loaded with the core action, followed by usage and scope-limitation. Every clause earns its place: no restatement of the name, 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 single-parameter read-only validator with no output schema, the description supplies the return shape, the usage context, and the scope limitation. An agent has everything needed to call it and to interpret its result without further inspection.

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 single 'vat' parameter is documented with a format example ('DE123456789'), so the schema carries the load. The description's phrase 'country-specific patterns' implies prefix handling but adds no syntax or country-list detail 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 verb and resource ('Check country-specific VAT number patterns') and scopes it to format validation rather than registration. The 'no VIES lookup' clause immediately distinguishes it from a real VAT verification service. Against a sibling set of is-*-safe format validators, the resource (VAT number) alone makes it identifiable.

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 a concrete usage context ('Use to screen VAT fixtures before form submission') and an explicit boundary ('no VIES lookup or active-registration check'), which tells the agent when this tool is insufficient. It does not name an alternative tool for active-registration checks, so it stops short of a full when/when-not/alternative triad.

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

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

Annotations already cover safety (readOnly, idempotent, non-destructive), but the description adds genuinely new behavioral context: that this is not a full CSS parser and output should be visually verified. That caveat about imperfect fidelity is exactly what an agent needs and cannot get from annotations.

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

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

Three short sentences, front-loaded with the core action and followed by the scope limit and the fidelity caveat. No padding or repetition.

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

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

For a simple one-parameter, no-output-schema read-only tool, the description covers purpose, scope boundary, and the key caveat about output fidelity. Nothing an agent needs to invoke it correctly 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?

There is a single parameter with 100% schema description coverage, including the 4096-character limit, so the schema does all the work. The description adds no format or syntactic detail beyond it, making baseline 3 appropriate.

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

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

States a specific verb and resource ('Reduce whitespace in CSS snippets'), and the resource name distinguishes it from the minify-html and minify-js siblings without needing further explanation. It stops short of explicitly contrasting its scope with those siblings, so it's clear but not fully differentiated.

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 basic stylesheet cleanup rather than production minification' gives both a when-to-use and an explicit when-not-to-use, which is real routing guidance. It doesn't name a sibling alternative for the production case, so it's 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?

Annotations already declare readOnly, idempotent, non-destructive and closed-world behavior, so the safety profile is covered. The description adds genuine value beyond that: it states the return type ('Returns an HTML string'), discloses content-preservation guarantees (pre, textarea, script, style), and warns to regression-test rendered output — a real caveat for a transformer. It does not mention errors or size-limit failures, 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?

Three tight sentences with the core operation front-loaded and no padding. The closing 'Regression-test rendered output' is a terse imperative that earns its place as a caution, though it could be slightly more explicit about why output may differ.

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 one-parameter, no-output-schema tool the description is nearly complete: it covers scope, return type and preservation semantics. Only edge-case behavior (invalid HTML, input over the 4096 limit) is left unspecified.

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

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

With a single parameter and 100% schema description coverage (the schema already documents 'Original HTML source as text, up to 4096 characters'), the schema carries the parameter burden. The description adds no syntax, encoding or escaping guidance for the html field, so the baseline 3 applies.

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

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

States a specific verb pair (remove comments, compact whitespace) and an explicit resource (HTML fragments), which cleanly separates it from the sibling minify-css, minify-js and minify-prompt tools. An agent can identify the operation 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?

Gives a clear negative boundary ('not full document compilation') and scopes the tool to 'small, controlled HTML snippets', which matches the 4096-character cap. It stops short of naming a sibling alternative for the full-document case, so it is clear context without full alternative routing.

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

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

Annotations already declare readOnly, idempotent and non-destructive, so the safety profile is covered. The description adds genuinely non-obvious behavior beyond that: output may be returned unchanged for complex syntax and the user is warned to regression-test it, which is useful operational 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?

Three tight sentences with zero filler, and the core purpose is front-loaded in the first clause. Every sentence earns its place: scope, exclusion, and the return/behavior caveat.

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 single-param, no-output-schema tool, the description usefully covers the return type ('Returns JavaScript text') and the caveat about unchanged output. Combined with annotations carrying the safety profile, an agent has what it needs, though a hint at size/edge limits beyond the schema would round it out.

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

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

With a single parameter and 100% schema description coverage, the schema already documents 'code' and its 4096-character limit. The description's 'small snippets' phrasing corroborates but adds no syntax, format or encoding detail beyond what the schema provides, so the baseline 3 applies.

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

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

States a concrete verb and resource ('Compact small JavaScript snippets') and scopes it against a stronger alternative ('not AST-aware production minification'), so an agent knows this is a basic JS compactor. It distinguishes from minify-css/minify-html only implicitly via the 'JavaScript' resource and never names a sibling, so it falls 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?

'Use for basic source cleanup, not AST-aware production minification' gives both a use case and an explicit exclusion, which is more than most definitions offer. It stops short of naming an alternative tool or stating concrete conditions, so it is clear context rather than full when/when-not/alternative guidance.

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

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

Annotations already cover readOnly, idempotent, and non-destructive, so the safety profile is free. The description adds real value beyond them: the output is trimmed/normalized text, no semantic compression occurs (filler phrases preserved), and there is a stated caveat about whitespace-significant prompts. No return-format or size-limit detail, but the behavioral contract is well communicated.

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 clauses, front-loaded with the core operation, then usage, then the caveat and return note. No filler. Slightly dense with semicolon packing, but every sentence earns its place.

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

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

With no output schema, the description correctly covers the return value ('trimmed text with normalized spacing'), plus the key limitation that semantic content is untouched. For a one-parameter, low-complexity formatting tool whose annotations carry the safety profile, this is essentially 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?

The single parameter is fully documented in the schema (100% coverage, including the 4096-character limit), so the schema carries this dimension. The description adds only an implicit sense of what the input is and does not describe input format or edge behavior beyond what the schema states; 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 operation (normalize prompt whitespace and line breaks) on a specific resource (prompt text), and immediately disambiguates from what 'minify' might imply by saying filler phrases are not removed. That distinction also cleanly separates it from the minify-css/minify-html/minify-js siblings without needing to name them.

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

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

Gives an explicit usage context ('use to compact formatting before calling a model') and a caution about when the operation is risky ('review prompts where whitespace carries meaning'). It stops short of naming the alternative to reach for in those whitespace-sensitive cases, so it is clear context without full exclusion routing.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), but the description adds real behavioral detail beyond them: the return is text in the selected format, and the operation is lossy in specific ways (trims strings, deduplicates rows, may drop mostly empty columns). The 'may drop' wording is honest disclosure of a data-dropping side effect.

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: purpose first, then usage routing plus a behavioral summary. No filler, no repetition of the name or title, and the alternative tool is named in the same breath as the constraint.

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 covers the return ('text in the selected format') and the transformations applied, which is what an agent needs for a 2-parameter tool. Minor gap: it does not note the 4096-character input ceiling or any failure behavior, though the length cap is already in the schema.

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

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

Schema description coverage is 100%, so both 'input' and 'format' (including the auto/json/jsonl/csv enum) are already documented in the schema. The description's mention of 'the selected format' and the three formats echoes the schema without adding syntax or format-specific semantics, 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 concrete verb pair (clean and compact) plus the exact resource (JSON, JSONL or CSV rows), and the title/description together make the 'minify structured data' role unmistakable against siblings like minify-css or minify-html. An agent can distinguish it from generate-dataset and is-json-safe 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?

'Use for small datasets' gives a clear scope condition, and it explicitly routes the agent to is-json-safe for the syntax-check-without-changes case. It stops short of stating what happens on larger inputs or naming other alternatives, so it is strong but not exhaustive.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true, so the safety profile is clear. The description adds valuable context about the return value ('replacement HTML with async loading and a config call, or original input if no G- ID exists') and warns about lost settings and consent review, going beyond what annotations provide.

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

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

The description is three tightly written sentences, front-loaded with the core action and followed by usage constraints and return behavior. Every sentence contributes necessary information without redundancy.

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

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

For a single-parameter transformation tool with no output schema, the description covers the essential behavior: what it rebuilds, when to use it, what it returns, and what to watch out for (lost settings, consent). Combined with annotations and the input schema, an agent has everything needed 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 coverage is 100% and the single parameter 'html' is fully described in the schema. The description does not add any additional meaning about the parameter beyond what the schema already states, so the baseline score of 3 is appropriate.

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

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

The description states a specific verb ('Rebuild') and resource ('GA4 gtag.js markup') and explicitly distinguishes the tool from GTM containers and consent setup. An agent can immediately understand what the tool does and what it does not handle.

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 explicit usage guidance: 'Use on existing GA4 snippets, not GTM containers or consent setup.' This tells the agent both when to use the tool and when to avoid it, and the caveat 'Review lost settings and consent' adds a clear post-use check.

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

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

Annotations already declare readOnly, idempotent, non-destructive, and closed-world, so safety is covered. The description adds value beyond that by disclosing the return behavior ('Returns plain text without interpreting log entries'), clarifying that log content is passed through untouched. It does not mention truncation or size-limit behavior, though maxLength 4096 is in the schema.

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 operation and then the use case and return behavior. Every sentence carries information and none is 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 one-parameter, read-only text transformation with a fully described schema and rich annotations, the description covers purpose, usage, and output nature. Nothing an agent needs to invoke it correctly is missing, and no output schema is required for this simple string return.

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

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

Schema coverage is 100% with a single self-documenting 'text' parameter, so the baseline is 3. The description adds no syntax, format, or encoding detail about the input beyond what the schema already states.

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

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

States a specific verb and resource ('Strip terminal ANSI escape codes from text'), which is unambiguous and clearly distinct from the minify-* and optimize-* siblings. An agent can identify the operation 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?

Gives a concrete usage context ('Use to make colorized logs readable for indexing or display'), which tells the agent when this tool applies. However, it names no alternatives or exclusions, so there is no explicit routing guidance against the sibling tools.

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