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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so the safety profile is covered. The description adds the routing behavior (type-dependent endpoint selection) and mentions HTTP 402 unpaid, which is a behavioral trait not in annotations. However, 'Score lower is better' is ambiguous and unexplained, and the description doesn't clarify what 'stack or Bearer 54k_.' means. It adds some context but is cryptic.

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 short and front-loaded with the legacy alias and preference for url.open. However, the trailing 'Score lower is better. HTTP 402 unpaid — stack or Bearer 54k_.' is cryptic and unexplained, which wastes the agent's time trying to interpret it. It's not concise in the sense of every sentence earning its place; the last part is confusing and likely noise.

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 legacy alias with annotations covering safety and idempotency, the description provides routing logic and a preference for the alternative. However, the cryptic 'Score lower is better' and 'HTTP 402 unpaid — stack or Bearer 54k_.' are unexplained and could mislead an agent. There's no output schema, so the description could have clarified return values or error handling, but it doesn't. It's adequate but with clear gaps.

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

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

Schema description coverage is 100%, so the schema already documents both parameters (q and type) with descriptions. The description adds the routing semantics: type=url maps to /v1/open, address|token maps to /v1/brief. This is useful but partially redundant with the schema's type description ('Prefer 'url' → /v1/open'). The description doesn't add much beyond what the schema already says, so baseline 3 is appropriate.

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

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

The description clearly identifies this as a legacy alias for url.open, with a specific verb ('brief'/'open') and resource (URL/address/token). It distinguishes itself from url.open by labeling itself as legacy and directing preference to url.open. However, the description is somewhat cryptic with 'Score lower is better' and 'HTTP 402 unpaid — stack or Bearer 54k_.' which may confuse an agent about the actual purpose.

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

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

The description explicitly says 'Prefer url.open' and provides routing logic: 'type=url → GET /v1/open; address|token → GET /v1/brief.' This gives clear when-to-use guidance and names the alternative. It doesn't explicitly state when NOT to use this tool, but the legacy alias designation and preference for url.open serve as a clear exclusion. The cryptic 'Score lower is better' and 'HTTP 402 unpaid' add some noise but don't undermine the 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 provide readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds only legacy status and the REST method GET, which is useful but minimal. It does not disclose response behavior, data format, or any deprecation consequences beyond the alias statement.

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

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

Two short, purposeful sentences. The legacy alias and endpoint are front-loaded, and the preferred alternative comes immediately after. There is no filler 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?

This is a low-complexity, deprecated simple read tool with a fully documented parameter. The description is complete enough to steer an agent to domain.dns, but it relies entirely on domain.dns's own description for actual behavior and does not mention return data or usage particulars.

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

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

The schema fully describes the single domain parameter with min/max length and an example, so the description does not need to repeat it. However, the description also adds no parameter-level guidance, matching the baseline of 3 for 100% schema coverage.

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

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

The description identifies the tool as a legacy alias for domain.dns and states the endpoint GET /v1/dns, but it never explicitly says what the operation does (e.g., resolving or reading DNS records). It points at a sibling rather than defining its own function, so an agent must infer the purpose from context.

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?

"Prefer domain.dns" is an explicit routing instruction: use the non-legacy sibling instead. Combined with "Legacy alias," it clearly tells the agent when not to use this tool and what alternative to pick.

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 readOnly=true, idempotent=true, destructive=false, and the description's 'GET' is fully consistent with them. Beyond annotations, it discloses that output carries fraud-signal style flags and that the tool is analytics-only, adding useful behavioral context about result shape and intended use. No contradiction.

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

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

Three tight sentences, roughly 40 words, front-loaded with the GET endpoint and core function, followed by the usage workflow and a one-word purpose qualifier. Every sentence earns its place; no wasted language.

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

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

For a low-complexity, single-parameter read tool backed by full safety annotations and 100% schema coverage, the description covers purpose, the recommended workflow, and output style. It stops short of detailing the return payload format (no output schema exists), but nothing critical is missing for correct invocation.

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

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

Schema coverage is 100% with a clear description and example for the single domain parameter ('Domain name without path. Example: example.com'), so the schema does the heavy lifting. The description's 'after url.open' weakly implies the input flows from a prior open step, but it otherwise adds no parameter detail — 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?

The description uses a specific verb 'summarize' with a clear resource — DNS A/AAAA/MX/NS records for a domain — and adds the distinctive 'fraud-signal style flags' output. It is scoped to a single domain, which the title 'Domain DNS' reinforces. However, it never explicitly differentiates from the sibling 'dns' tool, leaving the agent to infer the domain-scoping distinction.

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 workflow context — instructs composing with domain.whois/domain.tls for full domain hygiene after url.open, and stamps 'Analytics-only.' But it never names 'dns', its closest sibling alternative, nor states when domain.dns should be preferred over it. Context is present but exclusions and direct alternative routing are absent.

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 show readOnlyHint, idempotentHint, and non-destructive behavior. The description adds useful behavioral details beyond annotations: it discloses external data sources (crt.sh + probe), the summarized nature of the output, and the analytics-only scope. No contradiction 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?

The description is brief, front-loaded with the endpoint and purpose, and each clause adds value: what it returns, how it gets it, when to call it, and its analytics nature. No filler 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?

For a one-parameter, read-only tool, the description gives enough context: the input domain, expected output areas, data sources, and invocation timing. There is no output schema, but the description names the key result dimensions. It could mention error or latency behavior, but that is not essential for 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?

The single domain parameter is fully described in the schema with a clear example. The description adds no new parameter-level meaning, but because schema coverage is 100%, 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 clearly identifies the resource (TLS/CT) and the action ('summarize'), listing the specific outputs (issuer, validity, HTTPS reachability) and data sources (crt.sh + probe). It does not explicitly distinguish the domain.tls tool from the sibling 'tls' tool, so it loses the last point.

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

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

It gives explicit situational guidance: call after url.open/domain.dns when issuer/validity matters. It also marks the tool as analytics-only STATE. However, it does not explicitly say when NOT to use it or contrast it with an alternative 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 readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, so the agent knows this is a safe read. The description adds useful context by listing the specific WHOIS/RDAP fields returned and by noting that the data is analytics-only. However, the 'not clearance' phrase is ambiguous and could use clarification about intended vs. disallowed use cases.

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 compact and front-loaded: it identifies the endpoint, the action, the returned fields, the recommended sequence, and a caveat — all in two sentences. Every clause earns its place without unnecessary elaboration.

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 tool with rich annotations and a 100% schema coverage, the description is largely complete: it states what is returned, when to call it, and a usage caveat. The absence of an output schema is mitigated by the explicit field list. Minor gaps remain around error conditions and the exact meaning of 'not clearance,' but these do not prevent correct selection and invocation.

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

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

The input schema already covers the single 'domain' parameter with a clear description and example. The tool description reinforces that the parameter is a domain name via the WHOIS/RDAP context, but adds no new parameter-level meaning beyond the schema's 100% coverage.

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

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

The description states a concrete action ('look up'), the specific resource ('domain WHOIS/RDAP'), and enumerates the returned signals (registration, registrar, age_days, status, nameservers). This clearly differentiates it from sibling tools like domain.dns and domain.tls, even though a plain 'whois' sibling exists.

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 guidance on when to call it: 'Call after url.open when you need registration age / registrar signals.' It also adds a limitation: 'Analytics-only — not clearance,' which helps an agent decide whether this tool is appropriate. It does not explicitly name excluded alternatives, but the use-case framing is sufficiently 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 mark it as readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds no further behavior beyond the 'GET' endpoint, which is already implied by the annotations; there is no mention of side effects, edge cases, or safety beyond that.

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 very compact: 'Legacy alias for util.encode (GET /v1/encode). Prefer util.encode.' The first sentence front-loads the alias nature and the second sentence gives a clear action. It is slightly redundant with the title, but it is not bloated.

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

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

Given that the tool is a legacy alias with minimal parameters, no output schema, and strong annotations, the description is mostly adequate. It fails to explain what the tool does, though the name and schema fill much of that gap; pointing to util.encode covers substitution, but a functional preview would make it more complete.

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

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

Schema description coverage is 100%, with meaningful descriptions for 'q' (text to encode) and 'format' (base64/hex/url). The description provides no additional parameter detail, so it stays at the baseline for fully documented schemas.

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 says the tool is a 'Legacy alias for util.encode' but never states what the tool actually does (encode text). It mostly restates the title as a redirection, and the functional verb/resource is left to the tool name and 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?

'Prefer util.encode' is an explicit directive that names the sibling alternative and signals that util.encode should be used instead. For a legacy alias this is clear context, though it doesn't specify situations where the old tool might still be required.

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 mark it readOnly, idempotent, and non-destructive. The description adds the HTTP method, endpoint, and pricing. It doesn't mention output format/limits, but the safety profile is covered by annotations and 'page extraction' gives the main 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 terse sentences, front-loaded deprecation warning, then endpoint and cost. Zero fluff.

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

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

Covers purpose, routing, endpoint, method, cost dar. With full schema and annotations, enough to select/call, though no explicit output-shape description.

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%: both parameters have descriptions and format has an enum plus default. The description adds no per-parameter semantics beyond what's in the schema, so baseline 3.

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 exactly what the tool is: a legacy alias for url.fetch that performs page extraction via a GET request to a specific endpoint. This makes the operation clear despite the tool only being an alias.

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?

"Prefer url.fetch" is an explicit routing instruction that tells the agent to use the sibling instead of this tool. The first sentence also signals deprecated/legacy status, which is sufficient 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?

The description discloses that this tool is a legacy alias and a GET endpoint, adding deprecation and routing context beyond the annotations. Read-only/idempotent behavior is already covered by readOnlyHint and idempotentHint.

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

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

Two short sentences carry the essential deprecation and guidance information with no filler. The key point, 'Prefer util.hash', is front and center.

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 legacy alias, the description is sufficient: it names the canonical sibling, gives the endpoint, and the schema covers all inputs. It does not describe output format, but that is likely inherited from util.hash and not essential for routing decisions.

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 clear descriptions for both q and algo. The description itself adds no parameter-level meaning, so it stays at the schema-supported baseline.

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

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

The description clearly identifies the tool as a legacy alias for util.hash and gives the canonical GET endpoint. It does not explicitly state the semantic operation ('computes a hash'), but the alias, title, and parameter schema make the purpose 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?

Explicitly says 'Prefer util.hash', which directly tells the agent to use the sibling tool instead. This is clear when-to-use guidance with a named alternative.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is fully covered. The description adds the legacy-alias behavior and the GET endpoint, which is useful context beyond annotations. However, it doesn't describe what normalization does or any edge cases, but with annotations covering safety, a 3 is appropriate.

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

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

Two short sentences with zero waste. The legacy status and preferred alternative are front-loaded, and the endpoint is included as a useful pointer. Every word 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 one-parameter legacy alias with full annotation coverage, the description is nearly complete. It tells the agent this is a legacy alias, names the preferred tool, and gives the endpoint. The only minor gap is not explaining what normalization does, but the parameter name and schema description make that reasonably clear.

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% – the single parameter 'q' is documented as 'URL to normalize.' The description adds no additional parameter semantics 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?

The description clearly states this is a legacy alias for url.normalize and points to the preferred tool. It identifies the resource (URL normalization) and the action (normalize), though it doesn't describe what normalization does in detail. It distinguishes itself from siblings by naming the preferred 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?

The description explicitly says to prefer url.normalize, which is a clear usage directive. It doesn't explain when to use this legacy alias vs the preferred tool, but the instruction to prefer the sibling is sufficient guidance for an agent deciding between them.

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. The description adds meaningful behavioral context beyond annotations: the paste is ephemeral, has a TTL expiry, exists solely for agent handoff, and is not a long-term vault. No contradiction exists between annotations and description.

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

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

Two short sentences: one states the HTTP GET method and retrieval purpose, the other adds the usage boundary ('Agent handoff only – not a vault'). Each sentence is needed and impactful; 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?

For a simple one-parameter, read-only tool with no output schema, the description covers the core essentials (what to retrieve, the source, and the expiration condition). It does not specify error behavior if the TTL is exceeded, but for this level of complexity it is nearly sufficient.

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 thorough description of the 'id' parameter (returned by paste.write, example provided). The description text does not add further parameter-level meaning beyond restating that the paste id comes from paste.write and is relevant before TTL, so it stays at the baseline.

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

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

The description states a specific verb ('retrieve'), a resource ('ephemeral paste'), and the source ('by id from paste.write'), while noting the TTL constraint. It clearly differentiates from the write sibling and from being a vault, so an agent immediately knows what it does.

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

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

The description gives clear context: use it for agent handoff before the TTL expires, and explicitly says it is not a vault for long-term storage. It does not name sibling tools as alternatives (e.g., url.open for direct reads), so it lacks explicit when-not-to-use but provides enough situational 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?

The annotations already provide the full safety profile (readOnlyHint, idempotentHint, destructiveHint), so the description's lack of behavioral discussion is acceptable. The description does add the 'legacy' routing hint, which is a form of behavioral context, but it does not disclose anything else about execution, rate limits, or return 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?

The description is two short sentences with no wasted words; the most important fact (need to prefer paste.read) is front-loaded. It is entirely focused and 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 one-parameter, read-only legacy alias with complete schema and comprehensive annotations, the description is sufficiently complete. It could mention that the tool still functions, but that is implied by describing it as a 'legacy alias'; the routing guidance is the critical missing piece, which this description provides.

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 'id' parameter, which includes provenance and type. The tool description adds no parameter-level detail; per the baseline for high schema coverage, this 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?

The description identifies the tool as a legacy alias for paste.read, which implies a read operation on a paste resource, and it explicitly distinguishes the operation from paste.write via the pointed sibling name. However, it relies on the agent knowing what paste.read does rather than stating the behavior in absolute terms.

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 guidance: 'Prefer paste.read' clearly tells the agent which sibling to use instead and signals that this tool is only for legacy compatibility. This is a direct when-not-to-use statement with the alternative named.

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

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

The description adds meaningful behavior beyond annotations: it is ephemeral, stored in a KV with a 1-hour default TTL and 24-hour max, and is intended for agent handoff. It does not explicitly describe repeated-call behavior or idempotency, but it does not contradict the annotations.

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

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

The description is compact and dense: it states the endpoint, the action, the lifetime constraint, the intended use case, a non-goal, and the companion tool. No filler or redundant schema restatement.

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

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

For a simple two-parameter creation operation, the description gives the operation, constraints, purpose, and companion. It stops short of specifying the exact response shape or duplicate-call behavior, but 'returns an id' is sufficient given the schema's coverage.

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

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

Parameter semantics are fully covered in the schema, including descriptions and examples for content and TTL. The description adds no parameter-level detail, but with high schema coverage that is acceptable.

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

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

The description clearly states the action: store a short ephemeral paste and return an id. It also narrows the use case to agent handoff and explicitly contrasts with a vault, making the tool's role 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?

"Agent handoff only — not a vault" gives explicit when-to-use and when-not-to-use guidance, and "Pair with paste.read" directs the agent to the correct companion tool. This is strong usage orientation beyond the schema.

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

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

Annotations already indicate readOnlyHint=false, idempotentHint=true, and destructiveHint=false, so the description doesn't need to restate those. The description adds the legacy alias context and endpoint, which is useful. However, it doesn't disclose any behavioral details like whether the paste is created immediately, any side effects, or response behavior. The description is minimal but not contradictory.

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

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

The description is extremely concise: one sentence with the essential routing information. It front-loads the legacy alias status and the preferred alternative. No wasted words.

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

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

For a legacy alias tool, the description is sufficient for routing: it tells the agent to prefer paste.write. However, it doesn't explain what the tool does (creates a paste) or any behavioral context. Since the schema covers parameters and annotations cover safety, the main gap is the lack of a functional description. An agent could call it correctly but might not understand the purpose.

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

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

Schema description coverage is 100%, so the schema already documents both parameters (content and ttl_seconds) with descriptions. The description adds no parameter-specific meaning 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?

The description clearly identifies this as a legacy alias for paste.write and specifies the endpoint (POST /v1/paste). It distinguishes itself from the preferred paste.write sibling by explicitly naming it. However, it doesn't state what the tool actually does (creates a paste) beyond the alias relationship, so an agent unfamiliar with paste.write would not know the function.

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 explicitly instructs to prefer paste.write, which is a clear usage directive. It tells the agent when to use this tool (only as a legacy fallback) and names the alternative. This is strong 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?

Despite annotations already indicating read-only, idempotent, and non-destructive behavior, the description contributes useful behavioral context by flagging the tool as legacy and exposed via GET /v1/tls. It adds deprecation awareness without contradicting the annotations.

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

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

The description is very compact: two short sentences that first establish the legacy alias and then give the preferred replacement. There is no filler or redundancy, making it efficient and well structured.

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

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

For a simple one-parameter legacy alias with robust annotations, the description is adequate but not fully contained. It tells the agent the alias and preferred tool, but never mentions the returned content or behavior beyond 'GET /v1/tls', relying on domain.tls for semantics and on the absence of an output schema to imagine the result shape.

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 'domain' is fully described in the input schema with format details and an example, giving 100% coverage. The tool description adds no parameter-specific semantics, so the schema carries the entire burden, matching the baseline score of 3.

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 the tool is a legacy alias for domain.tls and identifies the underlying GET /v1/tls endpoint, but it does not say what the tool actually retrieves or produces. The action is only implied via the alias, so the purpose is clear as a compatibility shim but not as a functional operation.

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 explicitly says 'Prefer domain.tls' and names the direct alternative, giving an agent a clear directive to use domain.tls instead. It does not elaborate on specific conditional scenarios, but the precedence and alias nature are unambiguous.

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

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

Annotations already provide readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds valuable context: 'SSRF-safe', return elements (status, contentType, markdown|text), the 200KB cap, and the cost of $0.005. These are behavioral details beyond the annotations, giving agents essential information about limitations and side effects.

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

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

The description is two sentences with no redundancy. It front-loads the key info (what it does), then gives the URL endpoint, cost, safety, return details, and usage guidance. Every sentence earns its place, and the critical usage note is placed at the end for context.

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?

This is a simple 2-parameter tool with a strong schema. The description covers the essential context: purpose, usage guidance, cost, safety, return structure, and size limits. No output schema exists, so the description appropriately explains what the agent will receive (status, contentType, content). Nothing critical is missing for correct invocation.

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

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

Schema coverage is 100% with detailed descriptions for both parameters, so the baseline is 3. The description does not add extra meaning beyond the schema; it mentions format options but doesn't provide deeper semantic help. The schema already explains examples and preferences (e.g., prefer 'markdown'), so no deduction is needed, but there's no added value either.

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 the specific verb 'fetch' and resource 'public URL', explains the conversion to markdown/text, and clearly differentiates from siblings like 'url.open' by saying 'Page extraction / public URL to markdown' and 'Use after url.open when you need page body, not just risk signals.' This makes its purpose unmistakable.

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 provides clear usage context: 'Use after url.open when you need page body, not just risk signals.' This explicitly states when to use it. It doesn't explicitly state when not to use it or name alternatives for similar tasks (e.g., if you need plain text vs markdown is covered by the format parameter), but the guidance is strong enough. No explicit exclusions are given, which is why it's not a 5.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds value by disclosing the exact canonicalization behavior (lowercasing, fragment stripping, query sorting) and the 'Analytics-only' nature, which goes beyond the annotations. It doesn't mention error behavior or edge cases, but for a read-only normalization tool, the disclosed behavior is sufficient.

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 core behavior is front-loaded, the usage guidance is explicit, and the 'Analytics-only' qualifier is a useful final note. 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 single-parameter, read-only, idempotent tool with a 100% schema-covered parameter, the description is nearly complete. It explains what the tool does, when to use it, and its non-critical nature. The only minor gap is that it doesn't describe the return format, but since there is no output schema and the tool is simple, this is a small omission.

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

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

Schema description coverage is 100%, so the schema already documents the single parameter 'q' with an example. The description adds context about what normalization does to the URL but doesn't add new parameter-level semantics 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?

The description states a specific verb ('canonicalize') and resource ('a URL'), and enumerates the exact transformations (scheme/host lowercased, fragment stripped, query sorted). It also distinguishes itself from siblings by naming url.open and the condition for use ('when the URL is messy or duplicated').

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 explicitly says 'Call before url.open when the URL is messy or duplicated,' providing a clear when-to-use directive and naming the alternative. It also notes 'Analytics-only,' which signals a non-critical, observational use case. This is strong guidance for an agent deciding between tools.

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

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

Annotations already establish readOnly/openWorld/idempotent behavior, and the description adds meaningful context beyond that: the 0–100 score direction, the HTTP 402 failure mode with payment/auth guidance, and endpoint selection behavior. No contradiction exists between the annotations and the description.

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 dense but every sentence earns its place: purpose, score semantics, error/auth, routing, and workflow ordering. It front-loads the core purpose and keeps all operational details in a tight sequence with no filler.

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

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

Given there is no output schema, the description does enough by mentioning the risk score, page_risk/whois/page categories, and the 402 failure mode. It lacks an explicit response shape, but the risk-brief nature and score range give an agent sufficient context to invoke the tool and interpret the core 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 coverage is 100% and the schema already describes q and type, so the baseline is 3. The description adds real value by mapping type values to endpoints: 'For type=url calls /v1/open?q=; for address|token keeps GET /v1/brief?type=&q=', and it clarifies that q is the queried value. This goes slightly beyond the schema without replacing it.

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-resource mapping: 'Maps to GET /v1/open for URL checks (page_risk, whois, page)' and clarifies the broader role as a risk brief. It also disambiguates from domain.* siblings by instructing 'Call first for wrap-before-click; then domain.whois / domain.dns / domain.tls', making the tool's position in the workflow clear.

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

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

It gives explicit when-to-use guidance: 'Call first for wrap-before-click' and explains the ordering against domain.whois/dns/tls. It also provides conditional routing for type=url vs address|token, telling the agent exactly which endpoint pattern applies and noting the 402 unpaid case with preferred auth headers.

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

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

Annotations indicate readOnlyHint=false (not read-only), openWorldHint=true (makes external calls), idempotentHint=false (not idempotent), destructiveHint=false (not destructive). The description goes beyond by disclosing server concurrency limits and global inflight limits, which is valuable for rate-limit management. However, it doesn't explicitly state whether partial failures occur or how errors are handled for individual URLs, beyond a general page risk brief mention.

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

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

The description is a single dense paragraph with all critical operational details front-loaded: endpoint, paid-only, cap, concurrency, and usage preference. It wastes no wordsholly but is a bit lengthy; it could be slightly more concise but every sentence contributes a key fact.

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

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

Given the tool's moderate complexity (one array parameter, no output schema), the description covers all necessary aspects: endpoint, auth requirements, limits, concurrency, usage guidance, and human alternative. The absence of an output schema is compensated by stating that each URL returns the same risk brief as another tool; no critical information 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?

The schema already provides a thorough description for the 'urls' parameter (HTTP(S) URLs, 1-25, max length, example). The description adds the fact that each URL receives the same page_risk brief as the single GET endpoint, which is useful but not essential. Since schema description coverage is 100%, the description does not need to add more, but what it adds is minimal beyond the schema.

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

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

The description clearly specifies the action (bulk open URLs), the method (POST endpoint), and the exact resource (v1/open/batch). It distinguishes itself from the single-URL sibling tools like url.open by emphasizing 'bulk' and the endpoint. The title 'Bulk open URLs' is reinforced, and the description clarifies it's a paid feature, which is a distinct purpose.

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

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

The description explicitly states when to prefer this tool ('Prefer for allowlists') and points to a human alternative ('human bulk UI: https://linksafu.com/bulk'). It also implies when not to use it (e.g., for single URL analysis, use url.open). The paid-only nature is clearly stated with the 402 error without credits, guiding the agent away from attempting without proper setup.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds the HTTP endpoint and the intended use case but does not disclose output format, return structure, or edge-case behavior. With annotations covering the safety profile, a 3 is appropriate.

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 redundancy. The core operation and formats are front-loaded in the first sentence, and the intended context is stated in the second. Every word 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 utility with two fully-schema-documented parameters and annotations covering side effects, the description is adequate. It does not specify the return value or output shape, and there is no output schema, but the tool's simplicity and known encoding formats make this a minor gap rather than a critical omission.

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

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

Schema description coverage is 100%, so parameters q and format are already well-documented. The description merely restates the format options already present in the enum without adding deeper meaning such as encoding nuances or format-specific conventions. Baseline 3 applies.

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

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

The description states a specific verb ('encode') and resource ('text'), and enumerates the three supported formats (base64, hex, url-encoding). It clearly conveys what the tool does, though it does not explicitly contrast it with sibling tools like util.hash or encode variants, so it falls short of full distinction.

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

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

The phrase 'Utility for safe transport of strings between tools' implies a use case but does not provide explicit guidance on when to choose this tool over alternatives such as util.hash or url.normalize. No exclusions or explicit comparison with siblings are given, leaving selection partly 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 mark the tool read-only, idempotent, and non-destructive. The description adds meaningful behavioral context: it is a GET request, works on UTF-8 text, returns hex and base64 encodings, and is positioned as analytics-only rather than security-critical. No contradictions with annotations.

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

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

Two tight sentences, with the method, resource, and output format front-loaded in the first sentence. The second sentence adds positioning without bloat.

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 utility with fully documented parameters, the description plus schema is complete: no output schema exists, but the description states what the response will contain (hex + base64). No missing call prerequisites or side-effect warnings.

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 covers 100% of parameters with descriptions and examples for q and algo, so the baseline is 3. The description adds the output formats (hex + base64) and clarifies the input is UTF-8 text, which supplements the schema meaning for both parameters.

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

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

Description states a concrete operation: 'hash UTF-8 text' via a GET endpoint, enumerates the supported algorithms (sha256|sha1|md5), and specifies output encoding (hex + base64). This clearly distinguishes it from sibling utilities like util.encode and url.normalize.

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

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

The phrase 'Utility for fingerprints — not crypto advice' and 'Analytics-only utility' give a clear context: use for non-security fingerprinting and analytics. It doesn't name specific sibling alternatives or formal when-not cases, but the use context is strong enough to route an agent.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and non-destructive behavior, so the safety profile is covered. The description adds the useful context that this is a legacy alias and exposes the exact endpoint, but does not disclose additional behavioral details such as response format or rate limits. With strong annotation coverage, this is adequate.

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

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

Two sentences, no filler, with the legacy alias status and preferred alternative front-loaded. 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 one-parameter, read-only legacy alias with rich annotations and a fully covered schema, the description is nearly complete. It does not describe return values, but since the tool is explicitly an alias for domain.whois, an agent can reasonably infer behavior from the canonical sibling.

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

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

The schema covers 100% of the single parameter, including a description and example ('example.com'), so the schema already carries the semantic weight. The description adds no parameter-level information beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description clearly identifies the tool as a legacy alias for domain.whois and gives the endpoint (GET /v1/whois), which conveys its function indirectly. It distinguishes itself from the canonical sibling by explicitly naming domain.whois, though it never directly states 'performs WHOIS lookup'.

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 instruction 'Prefer domain.whois' gives explicit routing guidance toward the preferred sibling instead of this legacy alias. It does not spell out all conditions for when the alias should be used, but the legacy/alias framing makes the context clear.

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