Validators MCP

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.