Ambolt

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

Annotations cover the safety profile (readOnlyHint, openWorldHint), and the description adds genuinely useful context: the read is live via eth_call (no caching/staleness assumption) and enumerates the returned fields. It does not cover error behavior (invalid address, non-ERC-20 contract) or any rate limits.

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

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

One dense sentence, front-loaded with the resource and chain, then the return shape and read mechanism. 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?

No output schema exists, so the description has to carry return-value semantics, and it does (raw units, decimals, symbol, formatted amount). With only two fully-documented required params and annotations covering safety, the remaining gap is failure-mode behavior, which is minor.

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

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

Schema description coverage is 100%, so both parameters are already documented with their address patterns; baseline 3 applies. The description loosely reinforces that 'token' is an ERC-20 contract on Base via the USDC/WETH examples, but adds no format or constraint detail beyond the schema.

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

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

States a specific verb (retrieve balance) and resource (ERC-20 token balance of a wallet) and pins the chain to Base mainnet, which cleanly separates it from the solana_* siblings. The token examples (USDC, WETH, any token) make the scope unmistakable without opening a schema.

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

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

Usage is only implied by the resource name; the description never states when to use this versus siblings like base_token_info, nor any preconditions (e.g., must be an ERC-20 contract, not an NFT or native ETH). An agent can infer the obvious case but gets no routing help.

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 and openWorldHint=true, so the safety profile is covered. The description adds genuine behavioral value by disclosing what is inspected (bytecode for privileged functions, proxy admin, renunciation) and framing the output as facts without judgment, which is meaningful since there is 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?

It is a single dense sentence, front-loaded with the resource and then the enumerated facts, with the scoping caveat last. Every clause earns its place, though the packing is heavy.

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 fully carries the burden of explaining return contents by enumerating the facts, and the annotations cover the read-only/open-world profile. Nothing needed 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?

Schema coverage is 100% and the single parameter is fully documented with a pattern. The description only restates 'ERC-20 token on Base' and adds no syntax or format detail beyond the schema, so the baseline 3 applies.

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

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

The description states a precise verb+resource (returns verifiable on-chain facts about an ERC-20 token on Base) and enumerates exactly which facts: name, symbol, supply, ownership/renunciation, proxy/admin, pause state, and privileged functions in bytecode. An agent knows exactly what this tool yields 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?

There is no when-to-use or when-not-to-use guidance and no named alternative. The note 'Facts only: no verdict and no recommendation' scopes the output but does not tell the agent when to pick this over siblings like base_token_info or base_erc20_balance.

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 and openWorldHint=true, so safety is covered. The description adds meaningful context beyond that: data is fetched live via eth_call (not cached), and supply is returned in both raw and formatted form. It does not mention failure modes for non-contract addresses, but the added value is real.

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

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

Two tight sentences, front-loaded with the resource and output list, with the disambiguation clause at the end. Every phrase earns its place.

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

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

With no output schema, the description compensates by enumerating the returned fields, and annotations cover the safety profile. Nothing an agent needs to select or call it is missing.

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

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

There is a single parameter with 100% schema coverage, including a regex pattern and description, so the schema carries the full burden. The description adds nothing about the token address format, making baseline 3 appropriate.

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

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

Names a specific resource (ERC-20 token contract on Base mainnet) and enumerates exactly what it returns: name, symbol, decimals, and total supply in raw and formatted form. The 'facts only, no price or recommendation' clause cleanly separates it from price-oriented siblings like solana_token_price.

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 scope statement ('on Base mainnet') and the 'no price or recommendation' exclusion implicitly tell an agent when this tool is appropriate and when to reach for a price tool instead. It stops short of naming an explicit alternative or stating prerequisites, but the context is 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 declare readOnlyHint=true and openWorldHint=true, so safety is covered. The description adds real behavioral context: it enumerates the returned facts (success/revert status, block/time, sender, recipient, value, gas/fee, method selector, decoded ERC-20 transfers) and stresses 'Read live from the chain; facts only,' clarifying freshness and a no-interpretation stance.

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

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

Two compact sentences, front-loaded with the core action and scope, followed by a tight list of return fields. Every clause earns its place; nothing is redundant.

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

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

With no output schema, the description must carry the return-value burden, and it does so comprehensively by enumerating the fields an agent will get back. For a one-parameter read tool this is complete.

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

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

Schema coverage is 100% and there is a single parameter, so the schema fully documents the hash. The description restates 'by hash' and 'on Base' but adds no format or constraint details beyond what the pattern already encodes. 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 ('Look up') and resource ('a transaction on Base') keyed by hash, and it is immediately distinguishable from chain siblings like solana_transaction and from base_wallet_balances/base_erc20_balance by being the single-transaction lookup. An agent can pick it without opening the schema.

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

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

The phrase 'by hash' implies when it applies (you have a transaction hash and want its details), but there is no explicit when-to-use vs alternatives routing and no exclusions. Usage is inferable but not spelled out.

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

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

Annotations declare readOnlyHint and openWorldHint, so the safety profile is already covered. The description adds genuinely useful behavior beyond that: balances are read live from chain, only non-zero balances are returned, and no pricing or advice is produced. It does not cover pagination or failure modes, but for a read tool that is minor.

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

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

Three short sentences, each carrying distinct information, with the core capability front-loaded and the exclusions at the end. Nothing is redundant or 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 carries the burden of explaining results and does so partially by stating only non-zero balances appear and no price data is included. What the balance entries actually look like (amounts, decimals, symbols) is left unstated, a small remaining gap for a 2-param read 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% and both parameters carry their own descriptions and patterns, so the schema does the heavy lifting. The description's mention of 'any address on Base' and 'extra token contracts you list' mirrors the schema and does not add syntax or format detail beyond 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?

States a specific verb+resource with scope: ETH plus a named list of major tokens for any address on Base, plus user-supplied extras. This clearly separates it from base_erc20_balance (single token) and solana_wallet_balances (different chain) 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?

The description establishes clear context (live multi-token balance read for one address, extensible with up to 20 extra contracts). It also bounds expectations by ruling out price data and recommendations, but it never explicitly names an alternative tool or states when to prefer this over base_erc20_balance.

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 (readOnlyHint/openWorldHint), but the description adds real value: it discloses the no-email-sent side effect, the data basis ('9,000+ listed' domains), and the accuracy boundary that a pass does not prove mailbox existence. Return format is not described, keeping it from 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?

A single dense sentence with zero filler; the check list is front-loaded and the limiting caveat closes it. Every clause carries information an agent can use.

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 lookup with no output schema, the description covers what is checked and what is not, which is the crucial context. It leaves the response shape (per-check booleans vs. overall verdict) unspecified, a minor gap given no output schema exists.

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

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

The single parameter is fully documented in the schema (100% coverage) as 'Email address to check.', so the schema does the heavy lifting. The description implies the input is an email address but adds no format or constraint detail beyond that. Baseline 3 applies.

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

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

States a specific verb+resource ('email address check') and enumerates the five sub-checks performed (syntax, MX, disposable domain list, role address, typo detection). This specificity distinguishes it from generic siblings like dns_lookup and domain_rdap without naming them.

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

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

Gives a clear operational context ('without sending anything') and an explicit exclusion ('Does not confirm that a mailbox exists'), which tells the agent when the result is insufficient. It stops short of naming an alternative tool for mailbox verification, so it is short of a 5.

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

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

Annotations declare readOnlyHint and openWorldHint, so the safety profile is already covered and the lower bar applies. The description adds genuinely useful behavioral context by disclosing the returned measurements (5-minute snapshot, 24h average, cleanest/dirtiest windows), which is not restated anywhere else since there is 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?

A single sentence that front-loads the resource and then packs the returned metrics without any filler or redundancy. Every clause carries information an agent needs.

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

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

With no output schema and only one optional parameter, the description correctly compensates by enumerating the return contents, making the tool callable without opening anything else. Only the relationship to the price-focused sibling remains unstated.

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

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

Schema coverage is 100% and the single enum parameter is already documented, so the baseline would be 3. The description goes further by mapping the opaque enum tokens to meaning (DK1 = West, DK2 = East), which the schema's terse 'Price area.' note does not convey.

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

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

The description names a specific resource (CO2 intensity per kWh in Denmark, split by DK1/DK2) and precisely enumerates what the tool returns: the latest 5-minute value, a 24-hour average, and cleanest/dirtiest times. It does not explicitly contrast itself with the sibling dk_electricity_prices, so an agent must infer the distinction, but the substance is unambiguous.

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

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

Usage is only implied by the resource description; there is no explicit statement of when to prefer this over dk_electricity_prices or what conditions make it relevant. The DK1/DK2 split hints at the geographic selection, but no when-to-use or when-not-to-use guidance is given.

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 and openWorldHint=true, so safety is covered. The description adds real context beyond them: dual currencies (EUR and DKK per MWh), the quarter-hourly vs hourly nature, the returned summary statistics (min/max/average, cheapest hours), and the publication timing. It does not cover error or edge behavior, keeping it short of a 5.

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

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

Two tightly written sentences that front-load the core purpose and append the timing caveat. Every clause carries information; nothing is redundant.

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

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

With no output schema, the description partially carries the return-value burden by naming the currencies, units, resolution, and summary measures (min/max/average, cheapest hours). Combined with 100% parameter coverage and read-only annotations, an agent has enough to call it correctly, though the exact response shape is not spelled out.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters with defaults, enums, and patterns. The description restates the same concepts (one day, bidding area, hourly/quarter-hourly, cheapest hours) without adding syntax or format detail, 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?

The description gives a specific verb and resource: 'Day-ahead electricity spot prices for one day and bidding area.' It also states units (EUR/DKK per MWh) and resolutions, making the resource fully identifiable and distinguishable from the nearest sibling (dk_co2_intensity), which covers a different Denmark energy datapoint.

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, notably the timing cue 'Tomorrow's prices are normally published around 13:00 CET,' which tells an agent when tomorrow's data is actually available. There is no explicit when-not-to-use or named alternative, but no confusable sibling exists, so context is adequate.

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 and openWorldHint=true, and the description adds meaningful behavioral context: it performs DNS queries only and does not connect to the domain itself. It also discloses that SPF and DMARC presence/policies are reported. Rate limits, auth needs, and exact response structure remain unspecified.

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 tightly written sentences with zero waste. The core purpose and record types are front-loaded, followed by the important no-connection constraint.

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

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

For a simple two-parameter, read-only lookup tool with no output schema, the description covers what is resolved and what extra findings (SPF/DMARC) are reported. It does not describe the response shape in detail, but given the annotations and low complexity, it is nearly 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%, so the schema already fully documents both the domain pattern and the record-type enum values. The description lists the same record types but adds no syntax, format, or default behavior beyond what the schema provides, making the baseline 3 appropriate.

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

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

States a specific verb ('Resolve'), resource ('public DNS records'), and scope (the exact record types plus SPF/DMARC reporting). It is clearly distinguishable from siblings like domain_rdap, which handles registration data rather than DNS records.

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

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

The description implies usage for passive DNS inspection and notes that no connection is made to the domain, which hints at safe read-only use. However, it never explicitly says when to use this tool versus alternatives such as domain_rdap or url_to_markdown, leaving routing to inference.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds a scope boundary ('Bibliographic facts only'), which usefully tells the agent not to expect full text or abstracts, but says nothing about latency, rate limits, or how the best-match search ranks candidates. With annotations carrying the behavioral load, 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?

A single front-loaded sentence covering both modes and the return payload, with a short scope qualifier. Dense but every clause earns its place; the only minor cost is the long comma-separated field list, which could have been summarized.

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

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

No output schema exists, so the description's field enumeration usefully substitutes for return-value documentation. For a simple read-only lookup with no required parameters, the only real gap is the interaction between doi and query and the behavior of a failed best-match search.

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 doi, limit, and query with examples and bounds. The description adds no syntax, format, or precedence rules (e.g. what happens if both doi and query are supplied), so it does not go beyond structured data. 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 specific verb+resource ('Scholarly metadata by DOI') and explicitly covers the second mode ('best-match search by citation text'), then enumerates exactly what is returned (title, authors, journal, year, publisher, citation count, licence links, URL). No sibling overlaps with this resource, so differentiation is not needed, but the dual mode is unambiguous.

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

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

The two operating modes are described, implying 'use doi when known, query otherwise', and the schema param descriptions make the condition explicit ('when no DOI is known'). However, the description itself never states when to prefer one mode, nor any exclusions or fallback behavior if a best-match search finds nothing.

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 readOnlyHint and openWorldHint, so the safety profile is covered, and the description adds genuine context beyond them: it identifies the data source ('public RDAP registry'), lists what an agent can expect, and explicitly discloses that registrant and contact details are not returned. This scope-limiting caveat is useful disclosure not present in structured fields.

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

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

Two compact sentences, front-loaded with the action and data source, followed by the field list and the exclusion caveat. No redundant or filler text.

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 naming the returned fields (dates, status codes, nameservers, DNSSEC, registrar). It is nearly complete for a single-param read-only lookup; only minor gaps like rate limits or response format remain.

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 a single parameter, so the schema already documents the domain argument with a pattern and example. The description adds no format or syntax detail beyond what the schema provides, making the baseline 3 appropriate.

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

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

States a specific verb ('Look up') and resource ('a domain') scoped to 'the public RDAP registry', then enumerates the returned data fields. This distinguishes it from siblings like dns_lookup and ens_resolve, which serve different resolution purposes.

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

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

Usage context is implied by 'public RDAP registry' and the field list, but there is no explicit when-to-use guidance and no routing to alternatives such as dns_lookup or ens_resolve. The only boundary statement is the scope exclusion about registrant/contact details.

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 and openWorldHint=true, so the safety profile is covered. The description adds only that the output is raw data rather than advice, which is useful but thin; it says nothing about update cadence, caching, or the shape of the returned series.

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, zero filler, with the subject of the data front-loaded before the non-advice caveat.

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

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

For a read-only data tool with no output schema, the description covers what the response contains at a high level. It does not characterize the structure or units of the series, which an agent assembling a response would eventually need, but it is adequate 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% and the single 'history' parameter is fully documented in the schema (default 4, min 1, max 24). The description's phrase 'recent history' loosely echoes it but adds no syntax or semantics beyond 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 resource (the three ECB key interest rates) and what the payload contains (latest change dates and recent history), so the agent knows exactly what data comes back. It does not, however, distinguish itself from the close sibling fx_rate_ecb, which also deals with ECB-published rates.

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?

No when-to-use guidance, no exclusions, and no pointer to fx_rate_ecb for currency conversion versus policy rates. 'Data only, not advice' is a liability disclaimer, not usage 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 readOnlyHint and openWorldHint, so the safety profile is covered. The description adds genuinely useful behavioral context beyond that: it is restricted to onchain resolvers, and off-chain CCIP-read names report resolved=false rather than erroring. Return-shape detail is still limited.

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

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

Two dense sentences, front-loaded with the primary purpose and followed by the key constraint. No filler, no redundancy.

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

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

With no output schema, the description carries return-value burden and does disclose the resolved=false outcome field. For a 2-parameter read tool with full annotation coverage, this is nearly complete, though it could spell out the remaining return fields (e.g. the resolved address/reverse name).

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

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

Schema description coverage is 100%, so both parameters (name pattern/format and address reverse-lookup usage) are already documented in the schema, including the 'used if name is not set' precedence. The description restates the forward/reverse distinction without adding syntax or format detail beyond the schema, so baseline 3 applies.

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

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

States a specific verb (resolve) and resource (ENS name), covering both forward resolution to an address and reverse-record lookup, and names the network (Ethereum mainnet registry). An agent can immediately tell this differs from dns_lookup/domain_rdap, which handle DNS and RDAP rather than ENS.

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?

Clearly frames the two operating modes (name set vs address set) and adds a coverage caveat that off-chain CCIP-read names return resolved=false, which steers the agent's expectations. It stops short of explicit when-not-to-use or naming an alternative tool, but there is no ENS sibling to route to.

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 and openWorldHint=true, so safety and network behaviour are covered. The description adds genuine context by disclosing what comes back (validity, registered name, address) and that supplementary fields appear only 'where the member state publishes them', warning the agent that results vary by country.

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

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

Two tight sentences, front-loaded with the core action and followed by return semantics. Every clause carries information; nothing is redundant with the schema or annotations.

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 lookup with no output schema, the description covers purpose and return values adequately, including the important caveat about member-state-dependent fields. It stops short of covering rate limits, error behaviour for malformed prefixes, or expected latency.

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 fully documented there, including country-prefix format, space/dot handling, and the EL/XI special cases. The description adds no parameter-level meaning beyond 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 (check/validate) and resource (EU VAT number), and adds the scope qualifier 'valid and active'. It is easily distinguished from siblings like iban_validate or lei_lookup, which validate different identifier types.

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 purpose implies when to use it (VAT number verification), but the description names no alternatives, prerequisites, or when-not-to-use conditions relative to sibling validators such as iban_validate or nordic_company_lookup.

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

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

With readOnlyHint and openWorldHint already covering the safety profile, the description adds real behavioral context: publication timing (around 16:00 CET on working days), historical coverage back to 1999, and the key caveat that these are reference rates, not tradable quotes. It stops short of mentioning rate limits or response freshness beyond the publication schedule.

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

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

Two tightly written sentences with zero waste; the resource and scope come first, and the timeliness/tradability caveat follows as the most decision-relevant qualifier.

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 parameterless-data fetch tool whose annotations already signal a safe read, the description covers scope, timing, and the reference-vs-tradable distinction well. The one gap is that, with no output schema, the response shape (which currencies/rates are returned, how amount is applied) is not sketched at all.

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 base, date, amount, and symbols are already fully documented in the schema. The description's 'any base currency' and 'any date since 1999' loosely reinforce base and date semantics but add no syntax or default detail beyond what the schema provides, 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?

The description names a specific resource (ECB euro foreign-exchange reference rates), its full historical scope (any date since 1999), and its conversion behavior (any base currency) — far more precise than the bare tool name. It implicitly separates itself from siblings such as ecb_key_rates and us_treasury_rates by resource, but never explicitly differentiates.

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

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

Usage is implied rather than stated: the conversion framing ('converted to any base currency') signals the currency-conversion use case, and 'not tradable quotes' warns off trading use. There is no explicit when-to-use/when-not guidance and no alternative tool is 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?

Goes well beyond the readOnlyHint/openWorldHint annotations by disclosing the exact validation algorithm (mod 97), the country-length rule, the normalisation/grouping behaviour, and critically a negative guarantee that the account's existence is not verified. That limitation is the most decision-relevant trait and is not derivable from any structured field.

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

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

Two tight sentences, front-loaded with the core action and its mechanism, closing with the boundary condition. Every clause earns its place with no filler.

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

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

For a one-parameter validation tool with no output schema, the description covers mechanism and limits well, but it never hints at the result shape (e.g., a validity flag versus specific failure reasons per check). Minor gap given the tool's simplicity.

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

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

Schema description coverage is 100% ('IBAN, spaces allowed.'), so the schema already carries the parameter contract. The description's mention of a 'normalised and grouped format' describes the output presentation rather than adding input syntax guidance, 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 (validate) and resource (IBAN) and enumerates exactly what is checked: ISO 13616 mod-97 checksum, country-registered length, and normalised/grouped format. This clearly separates it from non-overlapping siblings such as eu_vat_validate or lei_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?

Gives clear context via 'offline' (no network lookup) and an explicit scope exclusion: 'Does not check that the account exists.' No alternative tool is named, but no sibling covers the same ground, so routing is 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 declare readOnlyHint and openWorldHint, so the safety profile is covered. The description adds value by enumerating returned fields (legal name, registry number, legal form, addresses, registration status) and by explicitly bounding scope to company-level data, which prevents misuse for natural-person screening. It does not discuss rate limits or empty-result behavior.

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

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

Two sentences, zero filler: capability and modes first, returned data second, scope boundary last. Nothing redundant and nothing 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 correctly compensates by listing the return fields, and the scope caveat covers the main risk. Minor gaps remain: no indication of pagination/limit behavior for name searches or what a no-match response looks like, though the limit parameter is documented in the schema.

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

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

Schema coverage is 100%, so pattern, maxLength, defaults and the LEI-precedence rule are all already documented in the schema. The description's '20-character LEI' and 'name and country' phrasing only restates schema content. Baseline 3 is appropriate when the schema carries the semantics.

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

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

States a specific verb (look up) and resource (LEI record / legal entities) and names the two operating modes: exact LEI lookup and name/country search. It also scopes the domain with 'Company-level data only', which helps distinguish it from person-oriented lookups. It stops short of explicitly contrasting with the nearby sibling nordic_company_lookup, which overlaps in the company-entity space.

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

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

The description implies when each mode applies (LEI for exact record, name+country for search) but never states a preference rule or exclusion, and the precedence rule ('If set, name and country are ignored') lives in the schema, not here. No mention of when an agent should prefer a sibling like nordic_company_lookup. Usage is inferable but not guided.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safe-read and external-live-data profile is covered. The description adds genuinely useful behavioral context: the result set is restricted to company-level data with no person records. It says nothing about rate limits, result caps beyond the limit param, or error behavior when an ID is not found.

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?

One tightly constructed sentence with the action and scope front-loaded, followed by a short scope-limiting clause. Every phrase carries information; 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?

With no output schema, the description helpfully enumerates the returned fields and the company-only limitation, which is enough for an agent to call and interpret the tool. The remaining gap is minor: it does not describe empty-result or not-found behavior, but for a read-only lookup that is not essential.

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

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

Schema coverage is 100%: each of the four parameters (id, name, limit, country) is already documented in the schema, including the id pattern, the NO/FI enum, and the id-over-name precedence. The description adds no syntax or format detail beyond the schema, so the baseline 3 applies.

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

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

States a specific verb (look up) and resource (companies in the Norwegian and Finnish company registers) plus the two lookup keys (registration number or name). It also enumerates the returned attributes (name, legal form, industry, address, registration date, status), so an agent knows exactly what this tool delivers. No sibling covers company-register lookups, so no differentiation is needed.

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

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

The description implies usage by naming the two lookup paths ('by registration number or name') and scopes out non-company data ('Company-level data only, no persons'). However, it gives no explicit when-to-use context, prerequisites, or precedence between id and name lookups, so the routing guidance is implied rather than stated.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds real context beyond that: exactly what a result contains and the explicit 'not a full security audit' limitation, which sets correct expectations for a public-database lookup.

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

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

A single front-loaded sentence names the operation first, then the returned fields, then the caveat. No redundant sentences; 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?

For a read-only lookup with no output schema, the description compensates by listing the response fields, and the scope caveat covers the main risk of over-trusting results. It is complete enough to call correctly, though nothing is said about rate limits or database coverage.

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

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

Schema description coverage is 100%, so name, version, and ecosystem are fully documented in the schema itself. The description only restates the ecosystems and the 'version' input implicitly; it adds no syntax or format meaning beyond 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 ('Check') plus resource ('npm or PyPI package version against a public vulnerability database') and enumerates the returned fields (advisory ids, aliases, severity, fixed version, latest version). No sibling tool performs vulnerability lookups, so there is no ambiguity to resolve.

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?

Implies the use case (check a package version for known advisories) and adds a boundary caveat ('Informational; not a full security audit'), which signals when not to over-rely on the result. However, no alternatives or explicit when-to-use conditions are 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?

Annotations already cover safety (readOnlyHint, openWorldHint), and the description adds value beyond them: it discloses the full output shape and a real limitation ('Author names are not returned'). It does not mention rate limits, error behavior on non-feed pages, or authentication, leaving minor gaps.

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

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

Three sentences, front-loaded with the core transformation, then input handling, then the caveat. Every sentence earns its place with no redundancy.

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

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

With no output schema, the description carries the burden of explaining returns and does so thoroughly (feed title, link, language, item fields). Combined with full parameter coverage and annotations, 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%, so the schema already documents all three parameters including defaults and bounds. The description restates the url flexibility ('feed URL or a normal web page') but adds no new syntax or format detail beyond the schema, so baseline 3 applies.

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

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

States a specific verb (turn into one clean JSON schema) and resource (RSS 2.0, RSS 1.0, Atom, JSON Feed), enumerating both input formats and the normalized output fields. It clearly differentiates itself from siblings like url_metadata and url_to_markdown by being feed-specific.

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 on when it applies: 'Give a feed URL or a normal web page and the feed is discovered from its link tags.' This clarifies input flexibility but offers no explicit exclusions or named alternatives among siblings.

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?

Goes well beyond the readOnly/openWorld annotations by disclosing concrete behaviors: network fetches of sitemaps, index following bounded at 10 files, and live status checks of sampled URLs. It does not mention rate limits, timeouts, or failure handling, but the behavioral profile of a read-only network-bound auditor is unusually well conveyed.

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

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

A single dense sentence front-loads the verb and resource, then lists checks in a readable enumeration ending with the return value. It is long but every clause maps to a distinct capability with no filler.

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

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

For a two-parameter, read-only audit tool with no output schema, the description covers scope, side effects (network fetches), bounds (10 index files, sampled URLs), and return nature (a list of concrete issues). A note on failure behavior or runtime would be needed for a full 5.

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

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

Schema coverage is 100%, so both parameters are already fully documented in the schema (including the 0-to-skip semantics of sampleUrls). The description adds no syntax, format, or default detail beyond it, 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?

Names a specific verb (audit), specific resources (robots.txt, XML sitemaps), and enumerates the exact checks performed. No sibling tool on the list covers this scope, so it is unambiguously distinguishable.

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

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

The description implies when to use it (site technical SEO audit) but never states when not to use it or names any alternative. Usage is inferable from the enumerated checks rather than explicitly guided.

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

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

Annotations already declare readOnlyHint and openWorldHint, so safety is partly covered. The description adds genuine context beyond that: it confirms nothing is signed or sent and previews exactly which values come back (slippage-adjusted minimum, price impact, route venues, fees in bps), which is useful for an agent deciding whether this is a dry-run.

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

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

Front-loaded with the core action and result fields in one dense sentence, followed by two short caveats. The trailing 'Not investment advice' is marginally useful but is the least load-bearing clause; otherwise there is no waste.

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

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

With no output schema, the description carries the burden of describing returns and does so by naming the quote fields. Read-only behavior and slippage handling are covered, though the omission of any pagination/expiry or freshness note for quotes is a minor gap.

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

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

Schema description coverage is 100%, so all four parameters are already documented in the schema, including the smallest-unit convention and slippageBps semantics. The description only alludes to slippage via 'minimum output after slippage' and adds no format or syntax detail beyond the schema, so baseline 3 applies.

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

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

States a specific verb and resource ('Get a swap quote on Solana through a DEX aggregator') and enumerates what the quote contains (expected output, minimum output, price impact, route venues, fees). The read-only clause implicitly separates it from the solana_swap_transaction sibling, though that sibling is never named.

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

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

The description implies usage context by declaring it read-only and unsigned, which suggests it is the preview step before executing a swap. However, it never explicitly says when to use this versus solana_swap_transaction or solana_token_price, leaving the routing inference to the 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 declare readOnlyHint=true and openWorldHint=true, and the description is consistent with them while adding real context: the transaction is unsigned, the caller signs locally, keys/funds are never seen, and no transaction is sent. It also discloses the response payload (base64 transaction, quote, fees in basis points including integrator fee). Missing only failure/error behavior, which is acceptable given 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 sentences, front-loaded with the core action, followed by the response shape and the custodial guarantee. Only the closing 'Not investment advice' boilerplate is arguably dispensable, but it is brief and legally relevant.

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 carries the burden of describing the return value and does so (base64 transaction, quote, all fees in bps), plus it clarifies the non-custodial boundaries. Only the absence of error/edge-case behavior keeps it from being fully complete.

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

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

Schema description coverage is 100%, with each parameter (taker, amount, inputMint, outputMint, slippageBps) already documented in the schema including the slippage fallback behavior. The description adds no parameter-level detail beyond that, so the baseline 3 applies.

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

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

States a specific verb and resource: 'Build an unsigned Solana swap transaction through a DEX aggregator.' The word 'unsigned' plus 'for a wallet you control' implicitly separates it from solana_swap_quote and other siblings, so an agent can route correctly without opening the schema.

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

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

The description explains the workflow context (you sign locally; the service never sends transactions) which implies when you'd want this over a quote, but it never names solana_swap_quote or any other alternative, nor does it state prerequisites or exclusions explicitly. Usage is inferable rather than stated.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so safety and external-data profile are covered. The description adds genuinely useful behavioral context beyond that: it's explicitly 'facts only' with no verdict/recommendation, and it warns that largest accounts may be pools or exchanges rather than individuals – a non-obvious interpretation caveat that changes how an agent should read the output.

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

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

Three tight sentences, front-loaded with the resource and returned fields, then the 'facts only' scope statement, then the largest-account caveat. No filler and every clause carries information.

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

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

For a single-param read-only lookup with annotations covering safety, the description is nearly complete: it enumerates returned fields, sets the non-advisory scope, and pre-empts a common misinterpretation. It doesn't mention source freshness or rate limits, but with no output schema and full annotation coverage the gaps are minor.

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 there is only one parameter (mint) fully documented in the schema. The description names the subject (a Solana token mint) but adds no format, constraint, or interpretation detail beyond the schema. Baseline 3 when the schema does the heavy lifting.

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

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

States a specific verb+resource ('Verifiable on-chain facts about a Solana token mint') and enumerates exactly what it returns: authority status, supply, decimals, token program, largest-account concentration, and market metrics. It is clearly distinguishable from siblings like solana_token_price (price only) and solana_token_search (discovery).

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

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

The usage context is implied by the description ('facts only, no verdict or recommendation'), which tells the agent this is a data-gathering tool, not an evaluator. But it never explicitly says when to use this vs solana_token_price or solana_token_search, and there are no exclusions or prerequisites stated.

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

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

Annotations already cover the read-only and open-world safety profile, so the description adds genuine value on top: it discloses the data source (aggregated market feed), the null behavior for unknown or unpriced mints, and the 50-mint batch ceiling. It does not mention rate limits, freshness/staleness of prices, or latency, which are relevant for a market feed.

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?

One densely front-loaded sentence carrying purpose, scope, and return fields, followed by a short null-behavior note and a disclaimer. Every clause earns its place with no redundancy.

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

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

With no output schema, the description correctly enumerates the returned fields, the batch limit, and edge-case handling (nulls for unknown mints), which is everything an agent needs to call and interpret results. Nothing material is missing for a single-parameter read tool.

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

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

Schema coverage is 100% with a single well-documented parameter, so the baseline is 3. The description adds beyond the schema by stating the 50-mint cap and, importantly, that unrecognized or unpriced mints come back as null rather than erroring — useful input-related semantics not encoded in the schema.

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

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

States a specific resource (Solana token mints) and exactly what is returned: USD price, 24-hour change, liquidity, decimals, up to 50 mints per call. It is clearly distinguishable from siblings like solana_token_facts and solana_token_search, and the 'aggregated market feed' source plus 'data only, not a recommendation' framing removes ambiguity about intent.

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

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

Usage is implied rather than stated: 'up to 50 mints in one call' signals batch price lookup, but the description never says when to prefer this over solana_token_facts, solana_token_search, or the swap-quote tools. No explicit when-to-use or when-not-to-use guidance is given.

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 and openWorldHint, so safety and open-world behavior are covered. The description adds non-obvious value: it discloses the returned fields, states the data is facts/public metrics, and warns that a high score is not a recommendation — a meaningful provenance/disclaimer that goes beyond 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?

Two sentences covering purpose, return fields, and a caveat. Front-loaded with the core purpose; the disclaimer sentence earns its place but slightly dilutes the crispness of the opening.

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 read-only, open-world lookup with annotations and full schema coverage, the description is complete enough: it covers what can be searched, what is returned, and the key pitfall (symbol collisions). No output schema exists, but the fields are enumerated, so return-value comprehension is handled.

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 description enumerates query keys (symbol, name, mint address) that match the query parameter, but it adds no format, syntax, or ambiguity guidance (e.g., case sensitivity, partial matching, mint-address format) beyond what the schema already documents. 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 (find) and resource (Solana tokens) with enumerated search keys (symbol, name, mint address) and the exact set of returned fields. It differentiates from siblings such as solana_token_price and solana_token_facts by being the lookup-by-identity entry 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?

Usage is implied by the enumerated search keys, but there are no explicit when/when-not instructions or named alternatives (e.g., 'use solana_token_facts for deeper details on a single token'). The warning to verify the mint address is context, not a routing rule.

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

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

Annotations already declare readOnlyHint and openWorldHint, and the description adds meaningful context beyond them: the tool only covers confirmed transactions, it reports both success and error outcomes, and the data is public on-chain with a "not advice" disclaimer. Rate limits and failure modes are unstated, keeping it below 5.

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

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

One dense sentence front-loads the verb and resource, then lists the return fields; a short trailing clause covers data provenance. Nothing is padded or redundant.

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

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

For a single-parameter read tool with no output schema, the description compensates by enumerating what comes back (status, time, fee, signers, programs, balance changes per account), and annotations cover the safety profile. An agent has everything needed 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?

There is a single parameter with 100% schema description coverage, including a base58 pattern, so the schema carries the parameter burden. The description only restates that lookup is "by signature," adding no format or validation detail beyond the schema. Baseline 3 applies.

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

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

States a specific verb and resource ("Look up a confirmed Solana transaction") and then enumerates the exact payload: status, time, fee, signers, programs, and per-account SOL/token balance changes. This clearly separates it from siblings like solana_swap_transaction (which constructs a swap) or solana_wallet_balances (which reads balances) without needing to open 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?

The triggering condition is explicit: you must have a transaction signature, and the target is a *confirmed* transaction, implicitly excluding pending/failed-submission queries. It never names an alternative tool or a when-not case, so it stops short of a 5.

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

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

Annotations already establish readOnlyHint and openWorldHint. The description adds substantial context beyond them: it sums multiple accounts of the same token, includes Token-2022 tokens, sorts largest-first, and discloses that very large wallets are truncated to the most valuable holdings. The truncation behavior is a non-obvious limitation worth flagging.

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

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

Four front-loaded sentences, each carrying information (scope, aggregation rules, data provenance, truncation limit). The 'not advice' clause is marginally expendable but adds a small amount of provenance framing.

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 carries the burden of describing return values, and it does: balance plus token holdings with symbols, USD prices and values, sorted by value. It stops short of describing the exact response shape or pagination semantics, but is adequate for a two-parameter read tool.

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

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

Schema coverage is 100%, so the baseline is 3. The description's 'largest first' aligns with the limit parameter's documented ordering but adds no syntax or format detail beyond what the schema already provides.

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

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

States a precise verb+resource: returns SOL balance and token holdings for a Solana address, with pricing detail. It is clearly distinguishable from siblings like solana_token_price or solana_token_facts, which operate on a token rather than a wallet.

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 use case (fetch a wallet's holdings) is strongly implied, but there is no explicit when-to-use or when-not-to-use guidance and no reference to alternatives such as base_wallet_balances for other chains. The 'not advice' line is a disclaimer, not 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 readOnlyHint and openWorldHint, so safety is covered; the description adds real value beyond that by listing the returned fields, stating the 7-day-ago default for publishedSince, and flagging the organisation-only scope. It stops short of describing result caps or ordering, but is well above the annotation bar.

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 return shape, then the scheduling tip. Nothing is redundant and no filler is present.

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 appropriately enumerates return fields and notes the default lookback, which is what an agent needs to interpret results. Minor gaps remain around result ordering and the limit/pagination behavior, but the definition is usable as-is.

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 each of the 7 parameters is already documented with format and examples. The description echoes the filter axes but adds no syntax or constraint detail beyond the schema, which is the expected baseline when the schema carries the load.

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

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

States a specific verb ("Find") and resource (recent EU public procurement notices) and enumerates the filter dimensions (buyer country, CPV, keyword, notice type). No sibling tool overlaps with TED procurement data, so the scope is unambiguous.

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

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

Gives concrete usage context — "Run it on a schedule with publishedSince to get new tenders" — and a scope exclusion ("Buyer organisations only, no contact persons"). It does not name an alternative tool, but no sibling competes for this task, so the routing risk is low.

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 and openWorldHint, but the description adds real operational context beyond them: robots.txt compliance, refusal of private addresses, no JS rendering, per-page billing, and that failed pages are reported with a reason and not charged. This meaningfully reduces invocation risk.

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

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

Two sentences that are front-loaded with the most important content (what data is returned) followed by constraints and billing behavior. Dense but every clause carries information; 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 read-only tool with no output schema, the description enumerates returned fields, states failure/billing behavior, and lists access constraints (robots.txt, no private addresses, no JS). The main gap is sibling differentiation against url_to_markdown, which would make the definition fully self-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 description coverage is 100%, so both parameters (url and urls) are already documented, including the 'Use this or urls' guidance and the 20-item cap. The description only restates 'one or many public URLs' and adds the 'public' constraint, adding little beyond the schema.

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

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

States a specific resource (link-preview metadata for public URLs) and enumerates the returned fields (title, description, canonical URL, OG/Twitter, favicon, language, hreflang, feeds, JSON-LD types), so the agent knows exactly what it gets. However, it never names or contrasts with the obvious sibling url_to_markdown, so differentiation is left to inference.

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

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

Usage is only implied through the field list and the 'no JavaScript rendering' caveat. There is no explicit when-to-use statement and no routing to alternatives such as url_to_markdown, so an agent must infer the choice rather than being told.

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 only declare readOnlyHint and openWorldHint; the description adds substantive behavior beyond that: robots.txt is respected, private and internal addresses are refused, and JavaScript is not executed. These are operationally decisive constraints an agent cannot infer from 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?

Two compact sentences: the first front-loads what is returned and how, the second carries constraints and the escape hatch. Every clause adds information with no 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?

With no output schema, the description covers the return shape (Markdown structure, absolute links), the input constraints, and the key limitation (no JS rendering) plus the alternative. Nothing essential for correct invocation is missing.

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

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

Schema description coverage is 100%, with both 'url' and 'maxChars' documented in the schema including bounds and default, so the description need not repeat them. It adds no additional semantics about the parameters, which is the expected baseline here.

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

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

The description names a specific verb and resource (fetch a public web page) and specifies the output precisely (main text as Markdown with title, headings, lists, tables, absolute links). No sibling tool overlaps with this capability, so differentiation is unambiguous.

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

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

It gives a clear when-not condition: pages requiring JavaScript should go to 'a rendering tool'. That is actionable, but the alternative is described generically rather than named, and no guidance is given on large pages or repeated calls.

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 and openWorldHint=true, so the safety profile is covered. The description usefully adds output ordering ('latest months first') and a usage disclaimer, but says nothing about data source, publication lag, or value units/format despite having 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 core resource before the ordering note and disclaimer; nothing is wasted. Minor deduction for the choppy fragment structure ('Latest months first.') rather than flowing prose.

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 no output schema, the description covers what data is returned, its granularity (monthly average), instrument coverage, and ordering. Only detail that would help an agent interpret results, such as units or publication lag, 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% for the single 'months' parameter (default 3, min 1, max 24), so the schema already does the explanatory work. The description's 'latest months first' only weakly reinforces the recency semantics and adds no syntax or format detail beyond the schema.

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

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

Names a specific resource (monthly average interest rates on US Treasury marketable securities) and enumerates the covered instrument types (bills, notes, bonds, TIPS, FRNs). The domain-specific scope clearly separates it from sibling rate tools like ecb_key_rates and fx_rate_ecb without needing to open 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?

'Latest months first' and the instrument enumeration imply this is a lookup for US Treasury yields, which is adequate implied usage. However, there is no explicit when-to-use, no guidance on choosing it over the similar-looking ECB/FX rate siblings, and 'Data only, not advice' is a disclaimer rather than usage guidance.

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

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

Annotations already cover safety (readOnlyHint=true, openWorldHint=true), so the bar is lower. The description adds genuinely useful context beyond them: it discloses the returned fields and the CC BY-SA 4.0 attribution obligation, which is a behavioral constraint an agent must honor when reusing the text. It stops short of failure modes (nonexistent title, redirects, disambiguation).

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

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

Two tight sentences: the first front-loads what is retrieved, the second adds the licensing constraint. No filler, no repetition of schema or annotation content.

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 carries the burden of describing return values, and it does so (extract, short description, URL, last-edit time) plus licensing. It is nearly complete for a read-only, open-world lookup; only error/redirect behavior is left unaddressed.

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

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

Schema description coverage is 100% and both parameters (title, lang) are documented in the schema with defaults, pattern, and lengths. The description only repeats 'by title and language' without adding format or edge-case semantics, 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+scope: it returns the lead-section summary of a Wikipedia article identified by title and language. It also enumerates what comes back (plain-text extract, short description, canonical URL, last-edit time), so an agent can distinguish it from generic fetch tools like url_to_markdown without opening the schema.

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

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

The 'lead-section' phrasing implies this returns only the article intro, not the full text, which implicitly signals when another fetch tool is needed, but no alternative or when-not condition is named. There is no guidance on language defaults, missing/disambiguation pages, or when to prefer it over url_to_markdown. Usage is therefore implied rather than stated.

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