automaton

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

With no annotations, the description carries the full load and does substantial work: it discloses determinism, no-LLM execution, ~30ms latency, a $0.01 USDC-on-Base price, and the exact x402 payment location (params._meta["x402/payment"]). It does not state what happens when payment is absent or what the response shape looks like, so it stops short of a 5.

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

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

The payment, latency, and endpoint facts are front-loaded and useful, but the middle clause enumerating sibling capabilities is misleading filler that an agent could act on incorrectly. Roughly a third of the sentence does not earn 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?

Payment mechanics and the transport endpoint are well covered, which is essential for a paid tool with no annotations. However, with 5 parameters and no output schema, the description never describes the return value (single result vs. all-equivalents map when 'to' is omitted) and never scopes the tool against its siblings.

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 baseline is 3; the description goes beyond the schema by disclosing a payment parameter (params._meta["x402/payment"]) that does not appear in the input schema at all — without this an agent could not invoke the tool successfully. It adds no detail on value/from/to beyond what the schema already says.

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

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

The opening clause 'unit + currency conversion by ratio' plus the name 'convert' identify the operation, but the sentence then enumerates timezone/date maths, cron expansion, entity extraction, and schema validation — capabilities that belong to the sibling tools agentkit__datetime, agentkit__extract, and agentkit__validate. An agent reading this cannot tell where this tool's scope ends and its siblings' begins.

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

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

There is no statement of when to use this tool versus agentkit__datetime, agentkit__extract, or agentkit__validate, even though the description itself lists their functions. No prerequisites or exclusions are given; the only routing signal is implicit in the tool name.

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

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

With no annotations at all, the description carries the full burden and does deliver substantive behavioral facts: deterministic, no LLM, ~30ms latency, exact answers, and a concrete pricing/payment mechanism ($0.01 per call in USDC on Base, paid via x402 in params._meta). What it omits is the read-only nature and any indication of what the response contains, but the cost and payment mechanics are unusually well specified.

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

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

Compact single paragraph with no filler sentences, and the capability summary is front-loaded. However, four of the five listed capabilities are irrelevant to this tool's schema, so that lead sentence consumes space while actively misleading rather than orienting.

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?

Five parameters, no output schema, and the description never characterizes the conversion result (e.g. what 'omit to returns all equivalents' yields) or how date/cron modes would be selected despite advertising them. The capability list raises expectations the schema cannot satisfy, leaving the agent without a correct mental model of the tool.

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

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

Schema description coverage is 100%, so the baseline is 3 and the description adds essentially no semantics about value/from/to/round/values beyond what the schema states. It does introduce a parameter absent from the schema (params._meta["x402/payment"]), which is useful but is payment plumbing rather than argument meaning.

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

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

The lead-in 'Deterministic mid-task utilities for AI agents' followed by a five-item capability list (conversion, date maths, cron expansion, entity extraction, schema validation) describes a whole toolkit, not this tool. The name 'datetime' and the input schema (value/from/to/round/values) only support unit/currency conversion, and the sibling tools agentkit__convert, agentkit__extract and agentkit__validate exist precisely for the other capabilities listed. An agent cannot reliably tell what this specific tool does from the description.

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 statement of when to use this versus agentkit__convert, agentkit__extract, agentkit__validate, or the many date tools in sibling set. The one genuinely useful usage constraint disclosed is the payment requirement (x402, USDC on Base, params._meta["x402/payment"]), which tells the agent a precondition for calling, but routing guidance is absent.

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

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

With no annotations, the description carries the full burden and does meaningful work: it discloses determinism ('no LLM'), latency (~30ms), a hard cost of $0.01 USDC per call on Base, and the payment channel in params._meta['x402/payment']. That payment prerequisite is exactly the kind of behavioral fact an agent needs before invoking. It stops short of describing failure modes or what a paid-but-failed call does.

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 block with no wasted filler, and the capability list is front-loaded. However, cramming five capability domains plus pricing plus an HTTP endpoint into one sentence makes it harder to parse than a short purpose statement followed by a payment note would be.

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

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

The advertised scope (datetime maths, cron expansion, entity extraction, schema validation) is far broader than the five-parameter conversion schema can express, with no explanation of how those modes are selected. With no output schema either, an agent has no way to know what a response looks like or which capability a given parameter set triggers.

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

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

Schema description coverage is 100%, so all five parameters (value, from, to, round, values) are already documented in the schema itself. The description adds no parameter-level meaning 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?

The description names concrete capabilities (unit/currency conversion, timezone maths, cron expansion, entity extraction, schema validation), but the tool is called 'extract' while its input schema only supports a single value/from/to/round conversion. An agent cannot tell which of the five advertised functions this call will actually perform, and the overlap with siblings agentkit__convert, agentkit__datetime and agentkit__validate is unaddressed.

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

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

There is no statement of when to use this tool versus agentkit__convert, agentkit__datetime or agentkit__validate, despite those siblings covering the same advertised capabilities. The only conditional guidance is implicit in the schema ('omit to to get all equivalents'), which lives in the schema, not the description.

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

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

With no annotations, the description does real work: it discloses determinism ('Exact answers, no LLM'), latency (30ms), a per-call price ($0.01 USDC on Base eip155:8453), the x402 payment mechanism and the HTTP endpoint. This is substantive behavioural context an agent could not infer elsewhere, though the payment parameter location (params._meta["x402/payment"]) is not reflected in the schema.

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

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

A single dense block that front-loads the utility list, but the list is over-broad relative to the tool's schema, so the early sentences actively mislead rather than orient. The commercial and transport details are compact and useful.

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 5-parameter tool with no annotations and no output schema, the description leaves core questions unanswered: what 'validate' actually returns, whether it validates JSON Schema or units or both, and how it differs from the sibling conversion tools. Payment and latency are covered, but operational completeness is not.

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 five parameters are already fully documented in the schema and the baseline of 3 applies. The description adds no parameter-level meaning beyond naming the x402 payment path, and it never clarifies how 'from'/'to' relate to the advertised schema-validation capability.

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 reads as a menu of unrelated utilities (conversion, timezone maths, cron expansion, entity extraction, format/JSON Schema validation) rather than stating what this specific tool named 'validate' does. It never resolves the tension between the tool name 'validate' and a schema built entirely around value/from/to conversion parameters, and it does not distinguish this tool from siblings agentkit__convert, agentkit__datetime and agentkit__extract which appear to cover the same listed functions.

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 guidance on when to call this tool rather than the closely related agentkit__convert, agentkit__datetime or agentkit__extract siblings. The only conditional information given is commercial (price, payment mechanism), not task-selection guidance.

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

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

With no annotations provided, the description carries the full burden and does well on the operational side: it discloses the exact price ($0.02 USDC on Base, eip155:8453), the x402 auth mechanism and where the payment payload goes (params._meta["x402/payment"]), plus the transport endpoint. It stops short of stating that the operation is read-only/non-destructive and says nothing about spec size limits or whether unresolved $refs cause failures.

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

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

The purpose statement is front-loaded and the payment details follow coherently. There is minor redundancy: the price is stated twice ('$0.02 via x402. Price: $0.02 per call in USDC on Base'), which wastes a clause in an otherwise tight description.

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 describe returns, and it does enumerate the categories of breaking changes reported. What is missing is the response shape — severity classification, whether unchanged items are included, and ordering — which an agent may need in order to consume the result correctly.

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

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

Schema coverage is 100% and both nested-object parameters are documented as 'current document' and 'proposed document'. The description adds no syntax or format guidance beyond the schema — notably it does not say inputs must be parsed JSON objects rather than URL strings — 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 (compare) and resource (two OpenAPI 3 JSON specs) and enumerates the exact report contents: removed paths, renamed parameters, new required fields, type changes. No sibling in the toolset performs spec diffing, so the agent can identify the right tool without ambiguity.

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 — an agent infers 'use this when you have a before and after spec'. There is no explicit when-not guidance, no statement about whether inputs must be full dereferenced documents vs $ref-laden ones, and no mention of alternatives for non-OpenAPI schemas.

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

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

With no annotations, the description does useful work by disclosing the $0.01 USDC cost, Base network, x402 payment location in `params._meta["x402/payment"]`, and HTTP GET endpoint. However, it omits what the tool returns, whether it is read-only, and any response or error behavior.

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

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

The description is reasonably compact and puts the endpoint and payment details in view, but it spends significant space on sibling endpoint `/report` and `/price` features instead of front-loading the purpose of this specific tool.

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

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

For a simple one-parameter tool with no output schema and no annotations, the description still leaves the core operation undefined and the `tokens` input format unexplained. It provides billing mechanics but not enough information to confidently invoke the tool.

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

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

The schema has one optional `tokens` string with 0% description coverage, and the description does not explain the expected format or semantics for this tool. The mention of 'up to 10 tokens' applies to `/price` bulk screening, leaving `basedue__due`'s parameter meaning unclear.

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

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

The description opens with the vague phrase 'Base token due diligence over x402' but never states what the `basedue__due` operation itself specifically does. It mostly advertises the `/report` and `/price` siblings, so an agent cannot tell this tool apart from `basedue__report`, `basedue__price`, or `basedue__exit`.

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 mentions that `/report` bundles checks and `/price` supports bulk screening, but gives no when-to-use guidance for `basedue__due` versus those sibling tools. The pricing and free-sample notes are commercial context, not selection criteria.

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

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

With no annotations, the description carries the full burden, and it does disclose genuinely useful operational facts: a $0.01 USDC charge on Base (eip155:8453), payment supplied via `params._meta["x402/payment"]`, and a free /sample. That payment/wallet flow is real context beyond the schema. However, it never states that the tool is read-only, what the call returns, or whether failed/unpaid calls are charged, so the behavioral profile is only partially covered.

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

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

The blurb is front-loaded with a service marketing line and an HTTP URL rather than the tool's function, then devotes sentences to sibling endpoints (/report, /price, /sample). Much of the text does not earn its place for this specific tool, and the one sentence that matters (exit cost) is buried mid-paragraph.

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 are no annotations and no output schema, so the description must define the operation and its result; instead it defines the pricing rails. An agent still does not know what `exit` returns or what the `tokens` argument accepts, which are the two things needed to invoke it correctly.

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

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

Schema description coverage is 0% for the single `tokens` string parameter, so the description must explain its format. The only near-relevant mention, "/price now takes up to 10 tokens per call for bulk screening," describes a different endpoint and leaves unclear whether `tokens` here is a comma-separated list, a cap, or a single symbol.

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 text opens with the service-wide slogan "Base token due diligence over x402" and then markets three other endpoints (/report, /price, /sample); the tool's own operation is never stated. The only hint at what this tool does is the phrase "position exit cost" buried inside the /report blurb. An agent must infer that `basedue__exit` computes exit cost for a token position, which is close to tautology-by-name rather than an explicit purpose statement.

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 condition is given for when to call `exit` instead of the sibling tools `basedue__due`, `basedue__price`, or the bundled `basedue__report` — even though the description explicitly advertises the other two endpoints' bulk/combined behavior. The comparative info present steers an agent toward the siblings, not toward this tool.

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

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

With no annotations, the description carries the full burden and does disclose the key non-obvious traits: cost ($0.01/call in USDC), network (eip155:8453), the exact payment injection point (params._meta["x402/payment"]), a free /sample, and the HTTP method/URL. It stops short of describing the response shape or whether failures still incur payment.

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 paragraph, but two of its sentences pitch /report and /sample rather than this tool, and pricing/payment boilerplate is repeated ("$0.01" appears three times). Useful content is present but not front-loaded on the actual operation.

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 1-param, no-annotation, no-output-schema tool, the description covers payment and cost well but leaves the return value, token format, and chain scope of the tokens unspecified. An agent knows how to pay but not precisely what to send or expect back.

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

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

Schema coverage is 0% and the single `tokens` property is an undescribed string. The description adds the meaningful constraint that up to 10 tokens are accepted per call, but it never states the encoding (comma-separated? addresses vs symbols?) or what happens beyond 10, so the agent can still easily call it incorrectly.

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?

"Base token due diligence over x402" plus "/price now takes up to 10 tokens per $0.01 call for bulk screening" hints that this endpoint returns token price data for a batch of up to 10 tokens. However, the first two sentences describe /report and /sample rather than this tool, so the agent must parse past sibling-endpoint marketing to infer what basedue__price actually returns.

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 contrast between /report (bundled DD + reference price + exit cost, one token) and /price (bulk, up to 10 tokens) implicitly tells the agent when to pick this tool for bulk screening. There is no explicit when-not guidance and no statement of prerequisites beyond the payment requirement.

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

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

With no annotations, the description carries full behavioral burden and does well: it discloses the $0.01 per-call cost, USDC on Base (eip155:8453), the x402 payment location (params._meta['x402/payment']), and the exact HTTP endpoint. It omits failure/refund behavior and rate limits, so not 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?

Purpose and the bundling value are front-loaded in the first two sentences, followed by pricing and endpoint logistics. The inline promotion of /price and /sample is dense but serves tool-selection, so there is little pure 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?

For a single-parameter tool with no output schema and no annotations, the description covers purpose, pricing, payment mechanism, and endpoint well. However it leaves the 'tokens' argument undefined and only loosely sketches the returned content (due diligence, reference price, exit cost) without enough detail 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 0% for the single 'tokens' parameter, and the description never defines its format for /report (count, delimiter, required vs optional) — the only 'tokens' mention ('up to 10 tokens') describes the sibling /price endpoint, which could actively mislead. The description does not compensate for the coverage gap.

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

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

The description names a specific resource (Base token due diligence) and makes the composite nature explicit: '/report bundles due diligence, cross-venue reference price and position exit cost in ONE $0.01 call.' That directly maps to the sibling tools basedue__due, basedue__price, and basedue__exit, letting an agent infer this is the all-in-one variant.

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 real alternatives: /price 'now takes up to 10 tokens per $0.01 call for bulk screening' and a free /sample on every endpoint, which implicitly tells the agent when to pick this tool versus the bulk-pricing route. It doesn't state explicit exclusions or prerequisites beyond payment, 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?

With no annotations, the description carries the behavioral burden and does disclose two genuinely important traits: the $0.01 USDC-on-Base (eip155:8453) x402 cost and that payment goes in params._meta['x402/payment']. That payment/auth requirement would be invisible from the schema and is exactly the kind of context that prevents failed calls. It stops short of stating read-only nature, rate limits, or response shape, so not 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?

Pricing is stated twice in near-identical form ('$0.01 per call in USDC on Base via x402' followed by 'Price: $0.01 per call in USDC on Base (eip155:8453)'), which is pure waste. The opening sentence is a family catalogue rather than a front-loaded statement of this tool's single job, so the useful payment detail is buried.

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

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

For a 3-parameter tool with full schema coverage and no output schema, the payment disclosure covers the main non-schema gap. However, the description leaves a real ambiguity unresolved: 'add N business days' versus a start/end/country schema with no count, and it never says what `add` returns (a resulting date). That mismatch is a completeness problem the schema cannot fix.

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% (end/start documented as YYYY-MM-DD, country enum documented as US federal vs UK England & Wales), so the schema already does the heavy lifting. The description adds no parameter-level semantics and in fact introduces confusion by implying an 'N' count that does not exist in the schema.

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

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

The text reads as a whole-family blurb ('is a date a business day, add N business days, count business days between dates, and list a year's holidays') rather than a statement of what this specific tool does. Three of those four listed capabilities map to sibling tools (bizcal_api__day, bizcal_api__between, bizcal_api__workdays, bizcal_api__year), so the description never distinguishes `add` from its siblings. The 'add N business days' phrasing also conflicts with the schema, which takes start/end/country and has no N parameter.

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 / when-not-to-use guidance is given, and the sibling tools are never named or routed to. An agent cannot tell from this text why it should pick `add` over `bizcal_api__between` or `bizcal_api__workdays`, especially given the overlapping start/end shape.

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

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

With no annotations, the description does carry real behavioral weight: it discloses the $0.01 USDC-on-Base (eip155:8453) x402 charge, where the payment goes (params._meta["x402/payment"]), and the underlying HTTP GET endpoint. It omits what the response looks like, whether 'end' is inclusive, and how holidays outside the stated country scope are treated.

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

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

The pricing sentence is duplicated near-verbatim ('$0.01 per call in USDC on Base via x402' then 'Price: $0.01 per call in USDC on Base (eip155:8453)'), and a service-level capability list is front-loaded where the tool's own function should be.

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 annotations and no output schema, so the description must carry everything. It says nothing about the return value (an integer count? a per-day breakdown?), range inclusivity, or error behavior for invalid/unsupported country ranges — the very things needed to call a counting tool correctly.

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

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

Schema coverage is 100% — start/end carry YYYY-MM-DD format and country carries an enum with a holiday-regime note — so the schema does the heavy lifting. The description's only added semantic is 'net of holidays', which is marginal on top of that.

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 enumerates the whole service's four capabilities (business-day check, add N days, count between dates, list year holidays) instead of stating which one this tool performs. With siblings bizcal_api__add, __day, __workdays and __year present, an agent cannot determine from the text that this endpoint counts business days between start and end.

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 and no mention of the alternatives, even though the sibling set clearly splits the four advertised operations. The agent is left to infer from the name 'between' alone that this is the counting-range tool.

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

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

With no annotations, the description carries the full burden; it does usefully disclose the paid access model (USDC on Base, eip155:8453, x402 payment via params._meta['x402/payment']) and the HTTP endpoint. However it says nothing about what a date-range call returns, how holidays affect the response, or error behavior.

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

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

The pricing statement is duplicated almost verbatim in consecutive sentences ('$0.01 per call in USDC on Base via x402' then 'Price: $0.01 per call in USDC on Base (eip155:8453)...'), wasting space, while the front-loaded capability list conflates multiple tools rather than pinning down this one.

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

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

No output schema exists and the description never states the shape of the response for a start/end range, which is the key unknown for this tool. Combined with the ambiguous scope against four sibling endpoints, the description is not sufficient to call the tool confidently.

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

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

Schema description coverage is 100%, with country enum values and date formats already documented in the schema ('US federal or UK England & Wales holidays', 'YYYY-MM-DD'). The description restates the geography but adds no new meaning about how start/end bound the query.

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 the resource (public holiday/business-day calendar for US and UK) but then enumerates four different operations — 'is a date a business day, add N business days, count business days between dates, and list a year's holidays' — which are precisely the sibling tools bizcal_api__add, bizcal_api__between and bizcal_api__year. Nothing in the text indicates which single operation this 'day' endpoint performs, so an agent cannot distinguish it from its siblings.

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

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

There is no when-to-use / when-not-to-use guidance and no mention of the alternative endpoints that cover the other three listed capabilities. An agent is left to guess between bizcal_api__day, bizcal_api__add, bizcal_api__between, bizcal_api__workdays and bizcal_api__year.

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

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

With no annotations, the description carries full burden, and it does add real behavioral context: cost ($0.01/call in USDC on Base, eip155:8453), the x402 payment path (params._meta["x402/payment"]), and the backing HTTP endpoint. However, it never explains how the caller selects between the four advertised operations — the schema has no mode selector and no 'N days' parameter — leaving a significant unexplained gap in how the tool actually behaves.

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

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

The purpose is correctly front-loaded in the first sentence, but the pricing and endpoint are stated redundantly — the $0.01 x402 price appears twice in slightly different wording — wasting space in a short description.

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

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

No output schema and no annotations, so the description must explain results and mode selection, and it does neither: it never says what is returned for each of the four operations (boolean, date, integer, list). Worse, the schema exposes only country/start/end, so the advertised 'add N business days' and 'count between dates' capabilities have no visible parameter to drive them — an agent cannot tell how to invoke those modes.

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 country/start/end are already documented (including the US federal vs UK England & Wales enum semantics), which sets the baseline at 3. The description adds nothing beyond that and does not clarify whether 'end' is inclusive or how start/end are interpreted in the 'add N business days' and 'is a business day' modes, where the range meaning is unclear.

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

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

The opening sentence names the domain (US/UK public holidays and business days) and enumerates four concrete operations, so an agent knows exactly what the tool covers. It does not, however, distinguish itself from the sibling tools bizcal_api__day, bizcal_api__add, bizcal_api__between and bizcal_api__year, which appear to expose the same four operations individually.

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

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

There is no guidance on when to call this combined tool versus the four single-operation siblings (day, add, between, year), nor any prerequisites or exclusions. The agent must guess based on the name alone.

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

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

With no annotations, the description must carry the load, and it does disclose two invocation-critical facts: the $0.01 USDC-on-Base charge and that payment goes in params._meta["x402/payment"]. It does not state that the call is read-only, what the response contains, or any rate-limit/failure 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?

Front-loaded with the calendar concept, but the pricing is stated twice almost verbatim ('$0.01 per call in USDC on Base via x402' then 'Price: $0.01 per call in USDC on Base (eip155:8453)'), wasting roughly a third of the text on a duplicate.

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?

Payment and endpoint information are present, but with no output schema the description never says what a 'list a year's holidays' response looks like (array of dates? names?), and it never disambiguates this tool from its four siblings. Adequate but with clear gaps for a 3-required-parameter call.

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 formats and an enum, so the schema already fully documents country/start/end. The description adds nothing about parameter semantics beyond restating US/UK scope, which the country enum description already covers — 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 opening states a resource ('Public holiday and business-day calendar for US and UK') but then lists four distinct operations — day check, add N days, count between, list a year's holidays — only the last of which is this tool. With siblings bizcal_api__day, add, between, and workdays present, the shared capability list makes it impossible to tell from the text alone which operation 'year' performs.

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

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

There is no when-to-use guidance and no routing to alternatives, even though four sibling tools cover the other listed capabilities. The only actionable instruction is payment mechanics, not selection guidance.

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

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

With no annotations present, the description carries the full burden and does unusually well: it discloses the payment model ($0.01 per call in USDC on Base, eip155:8453), the x402 payment channel (params._meta["x402/payment"]), the transport endpoint, a hard batch ceiling of 25, and the existence of free /scan and /t/<address> pages. It does not state rate limits, failure/refund behavior on failed calls, or what a successful response contains, which keeps it below a 5.

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

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

It is a single dense paragraph that front-loads the capability list and then the cost/transport facts, with essentially no filler. The one weakness is that the payment and pricing details are interleaved with the capability claims rather than separated, but no sentence is wasted.

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

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

For a 5-parameter, zero-required, annotation-free tool with no output schema, the description covers cost, payment, endpoint and batch limits well. What it omits is the mapping from parameters to operations and any indication of return shape or error behavior, which matters because there is no output schema to fall back on and the breadth of the listed capabilities makes the response format genuinely unpredictable.

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 80%, so the baseline is 3. The description adds real meaning for two things the schema does not fully cover: the 25-address ceiling on the addresses array and the out-of-schema params._meta["x402/payment"] field that must be supplied for a paid call. It still does not explain which parameter selects which operation (hash→tx, number→block, address→balance/token) beyond what the schema's parenthetical hints already say.

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 enumerates concrete resources (gas, blocks, balances, token metadata, tx status, nonces, token safety verdicts) under a 'read-only Base and Ethereum chain data' umbrella, so the agent knows it is a read tool for EVM chain data. But the name says 'balance' while the description spans nine different data types, and nothing distinguishes this from chainread__gas, chainread__block, chainread__tx, chainread__nonce, chainread__token, chainread__verdict or chainread__batch. An agent cannot tell from this text whether this tool is a superset or a duplicate of those siblings.

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

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

There is no statement of when to use this tool versus the many highly specific chainread__* siblings that appear to cover each listed capability. The only conditional information given is about pricing and free pages, not about tool selection. The agent is left to infer whether calling chainread__balance with a hash is equivalent to chainread__tx, or whether one should be preferred.

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

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

With no annotations, the description carries the full burden and does disclose key traits: read-only, $0.01 per call in USDC on Base, payment passed via params._meta["x402/payment"], and the underlying HTTP endpoint. It does not cover failure modes (e.g., behavior beyond 25 addresses) or response shape, but the cost/payment/auth disclosure is substantive.

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?

Pricing and endpoint details are packed usefully, but the opening clause front-loads a generic service catalogue rather than the batch-specific capability, and the mixed 'tokens'/'addresses' wording costs clarity for a single-sentence description.

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 annotations and no output schema, so the description must do the work; it covers cost, payment, and the 25-item cap, which is helpful, but says nothing about what a batch response contains or how partial failures are reported. Adequate but with clear gaps for a paid multi-item 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 80%, so the schema already documents hash, number, address, addresses and the chain enum; baseline is 3. The description adds the 25-item batch limit and the _meta payment parameter, but its 'tokens' framing conflicts with the 'addresses' parameter and it never explains which of the five params apply to this batch endpoint.

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 the resource (Base/Ethereum chain data) and states 'Batch up to 25 tokens', but most of the text describes the whole chainread service family (gas, blocks, balances, tx status, nonces, verdicts) rather than what this specific batch tool returns. It also wavers between 'tokens' and the schema's 'addresses (up to 25)', leaving the actual unit of batching ambiguous.

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 guidance on when to choose batch over the single-entity siblings (chainread__balance, chainread__token, chainread__tx). 'Batch up to 25 tokens' implies a many-at-once use case, but there are no explicit conditions, exclusions, or alternatives named.

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

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

With no annotations provided, the description carries the full burden and does substantial work: it declares the tool read-only, names the two supported chains, states the price ($0.01 USDC on Base eip155:8453), and explains that payment goes in params._meta["x402/payment"]. It stops short of describing what happens on unpaid or failed calls and gives no rate-limit or error behavior.

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

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

The capability list, pricing and payment mechanics are front-loaded and the HTTP endpoint is placed last, which is the right ordering. The first sentence is a long comma-chained list that could be tightened, but almost every clause carries actionable 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 five-parameter, zero-required, multi-mode tool with no output schema, an agent still needs to know which parameter selects which operation and whether parameters combine. Pricing and payment are fully covered, but mode selection and failure behavior are not, leaving a real gap for a tool this flexible.

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 80%, so the schema already documents most parameters, and the baseline is 3. The description adds one useful constraint — batch up to 25 tokens — that corroborates the addresses array cap, but it doesn't clarify which parameter triggers which sub-resource or whether they are mutually exclusive.

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 lists concrete resources (gas, blocks, balances, tx status, nonces, verdicts) and states it is read-only over two chains, so the agent knows what class of data it returns. But it never explains why an agent should pick this tool over siblings like chainread__gas, chainread__balance or chainread__tx, which appear to cover the same ground, and the name 'block' implies a narrower scope than the description claims.

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

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

There is no when-to-use guidance and no exclusion of alternatives, despite nine chainread__* siblings covering individual resources. The description also never says whether the parameters select different sub-resources (the schema hints at /tx, /block, /batch) or whether they must be passed one at a time.

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

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

With no annotations, the description carries the full burden and does meaningful work: it declares the tool read-only, discloses a paywall ($0.01 USDC on Base, eip155:8453) and the exact payment carrier params._meta["x402/payment"], states a batch ceiling of 25, and gives the concrete HTTP endpoint. Missing are failure modes (what happens when payment is absent/invalid), rate limits, and the shape of a successful response.

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 paragraph that front-loads the core capability list before pricing and endpoint details. It is compact with no filler sentences, though the capability enumeration is a shotgun list rather than a crisp statement of what this endpoint alone returns.

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

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

No output schema and no annotations means the description must cover invocation and returns; it covers payment and batching but not which parameter selects which resource or what the response looks like. The schema's per-property route hints ('for /tx', 'for /block', 'for /batch') do part of the job the description omits.

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 80%, so the schema already documents hash, number and addresses with their route hints, and the description's 'Batch up to 25 tokens' only restates the addresses constraint. The description adds no meaning for chain (the only enum) and references a params._meta["x402/payment"] field that does not exist anywhere in the input schema, leaving the payment parameter undescribed.

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

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

The description says it reads Base and Ethereum chain data and enumerates resource types (gas, blocks, balances, token metadata, tx status, nonces, verdicts), but that enumeration describes the entire chainread__ family rather than this specific tool. With siblings chainread__gas, chainread__block, chainread__balance, chainread__token, chainread__tx, chainread__nonce, chainread__verdict and chainread__batch all present, an agent cannot tell what 'code' uniquely does or which one to pick.

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 / when-not-to-use guidance and no reference to any sibling tool despite eight closely overlapping chainread siblings. The only routing-adjacent information is pricing and a mention of free /scan and /t/<address> pages, which is commercial detail rather than invocation guidance.

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

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

With no annotations, the description carries the full burden and does well on the hard parts: it declares read-only scope, states the price ($0.01 USDC on Base, eip155:8453), names the x402 payment field (params._meta["x402/payment"]), states the batch cap of 25, and lists which endpoints are free. It omits failure modes, rate limits, and what a successful response looks like, but the payment/auth disclosure is well beyond the norm.

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

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

The text is dense and front-loaded with a capability list, then pricing, then the HTTP endpoint, and every sentence is informative in isolation. However, it is a catalog blurb copied across the whole family rather than a description of this tool, so its length is spent on capabilities the caller won't get from this one endpoint.

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 five-parameter tool with zero required parameters and no output schema, the description should say what the gas call returns and which parameter selects the gas sub-resource. Instead it explains the service and its pricing, leaving the actual invocation — presumably 'chain' plus some implicit mode — undocumented anywhere.

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 80%, so the schema already explains hash, number, address, and addresses. The description adds only one marginal detail — a 25-address batch ceiling — and never maps parameters to the gas operation or explains why 'chain' is an enum of base/ethereum. Baseline 3 fits, but nothing here disambiguates the five optional, none-required parameters.

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

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

The tool is named 'gas' but the description enumerates an entire service's surface — gas, blocks, balances, token metadata, tx status, nonces, verdicts — without saying what this specific endpoint returns. An agent cannot tell from this text whether calling chainread__gas yields a gas price, a block, or a batch of token safety scores; the sibling list (chainread__block, chainread__tx, chainread__balance, chainread__token, chainread__nonce, chainread__batch, chainread__verdict) makes the overlap actively confusing.

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 is given relative to the nine chainread siblings that each cover one of the listed capabilities. The only routing hint is incidental (free /scan and /t/<address> pages, batch up to 25), which does not tell the agent when to pick gas over block, tx, or nonce.

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

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

With no annotations, the description carries the full burden and does well: it discloses read-only behavior, pricing ($0.01 per call in USDC on Base), payment mechanism (x402 in params._meta["x402/payment"]), batch limit (25 tokens), free pages, and the HTTP endpoint. It stops short of error handling, rate limits, or auth failure behavior, but covers key operational traits.

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

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

The description is a run-on collection of capabilities, pricing details, and endpoint info without clear hierarchy. Key routing information (when to use, how to choose among operations) is absent or buried. It is not excessively long, but the structure does not front-load decision-critical guidance.

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

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

For a complex tool with five parameters, multiple operation modes, no output schema, and no annotations, the description omits crucial context: how the parameters map to distinct endpoints, what the response formats look like, and how to handle payment failures. It gives pricing but not enough operational guidance for reliable invocation.

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

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

Schema description coverage is 80%, so the schema already documents most parameters. The description adds a batch-size limit ('up to 25 tokens') and context that parameters map to specific endpoints (/tx, /block, /batch), but this largely duplicates the schema's own hints. Baseline 3 applies when the schema does the heavy lifting.

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

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

The description clearly states a verb and resource: 'Read-only Base and Ethereum chain data over x402' and enumerates specific data types (gas, blocks, balances, etc.). However, it does not differentiate this tool from the many specific chainread__ siblings (gas, balance, block, tx, etc.), leaving ambiguity about when to choose this multi-purpose tool over the focused ones.

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 guidance is given on when to use this tool versus alternatives. The description lists capabilities but never states prerequisites, exclusions, or which sibling tool to pick for a given task. The only hint is 'Free /scan and /t/<address> verdict pages', but this does not help an agent choose between this and chainread__verdict or others.

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

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

With no annotations, the description does real work: it discloses read-only semantics, exact pricing ($0.01 USDC on Base / eip155:8453), the x402 payment mechanism and its location (params._meta['x402/payment']), and the HTTP endpoint. That auth/payment context is exactly what structured fields cannot carry. It stops short of describing the return shape (nonce value, pending vs. latest) and doesn't mention 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?

The first and longest clause is a catalogue of capabilities irrelevant to this specific tool, so the actual purpose is never front-loaded. Pricing, batching, and free-page marketing are packed in ahead of and instead of the operation itself. It is compact but misallocated.

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

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

No output schema and no annotations exist, so the description carries the full burden, yet it never says what a nonce response contains or whether chain/address are effectively required despite zero required parameters. Payment and transport are covered; core invocation semantics for this operation are not.

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 80%, so the schema already documents hash, number, address, and addresses. The description adds nothing about which parameter drives this tool (presumably address plus chain), and the repeated batch-of-25 note is redundant with the schema's own 'Up to 25 addresses' text. 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 is a family-level blurb enumerating gas, blocks, balances, token metadata, tx status, nonces, and token safety verdicts rather than stating what this tool does. 'Nonces' appears once in a list of seven capabilities, with no indication that this tool reads an account nonce for a given address. An agent cannot tell chainread__nonce apart from chainread__balance or chainread__tx from the text alone.

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

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

No guidance on when to use this tool versus the many sibling reads (chainread__balance, chainread__tx, chainread__block, chainread__batch). The only conditional information given ('Batch up to 25 tokens', 'Free /scan and /t/<address> verdict pages') maps to other siblings, not to nonce 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 no annotations, the description carries the burden, and it does disclose genuinely useful traits: read-only nature, $0.01 USDC price on Base, x402 payment passed in params._meta["x402/payment"], free /scan and /t/<address> pages, and a 25-item batch cap. It does not disclose error/failure behavior (what happens unpaid or on the wrong chain), rate limits, or how the single tool dispatches to the many sub-endpoints it advertises.

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 dense but front-loaded: capabilities first, then pricing and transport. Nearly every clause carries information an agent needs (price, payment channel, batch cap, endpoint). The long capability list is slightly wasteful given the near-duplicate siblings, but nothing is genuinely 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 5-parameter tool with no required params, no annotations, and no output schema, the description covers cost and payment well but leaves the routing model opaque: five optional params apparently target different sub-endpoints, and the text never states which combination triggers which behavior or what is returned. An agent could construct a call but could not predict its result.

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

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

Schema coverage is 80%, so the baseline is 3. The description adds real value for the payment field not present in the schema (params._meta["x402/payment"]) and clarifies the 25-item cap on addresses. However, it never explains how hash/number/address/addresses select among the advertised operations, which is the central parameter question for this tool.

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

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

The description names a concrete resource class (read-only Base/Ethereum chain data) and enumerates the data types it can return, so the domain is clear. But it reads as a bundle of many capabilities that each map to a dedicated sibling (chainread__balance, chainread__tx, chainread__block, chainread__nonce, chainread__verdict), and it never explains whether this tool is a superset, a router, or an alias. An agent cannot tell from the text why it would pick this over the specific siblings.

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

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

There is no when-to-use guidance and no mention of alternatives, despite the sibling list containing a near one-to-one match for every capability named (balance, block, tx, nonce, verdict, batch). The only conditional statement is 'Batch up to 25 tokens', which constrains one input rather than steering tool selection.

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

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

With no annotations, the description carries the load well: it declares read-only behavior, states the price ($0.01 USDC on Base), names the payment mechanism and where the payment goes (params._meta["x402/payment"]), notes free verdict pages, and caps batching at 25. It omits rate limits and error/payment-failure behavior, 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?

The pricing and transport details are genuinely useful, but the opening sentence is an undifferentiated pile of resources and the endpoint URL is buried at the end. Real information, poor front-loading and weak structure.

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

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

A zero-required-parameter endpoint where five optional parameters dispatch to different internal routes needs an explicit explanation of that dispatch, and none is given. The description covers payment well but leaves the core calling model ambiguous, which is the biggest gap given no annotations and no output 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 80% and each parameter already has an inline description, so the baseline is 3. The description adds only the batch limit of 25, which the addresses parameter description already states, so there is essentially no net meaning added.

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 lists resources (gas, blocks, balances, token metadata, tx status, nonces, verdicts) but never says which single operation this tool performs, and its name says 'tx'. Since dedicated siblings exist for nearly every listed resource (chainread__gas, chainread__block, chainread__balance, chainread__token, chainread__nonce, chainread__verdict), the broad enumeration actively blurs the tool's identity rather than distinguishing it.

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 instruction and no routing guidance relative to the many chainread siblings. The parameter descriptions mention internal routes (/tx, /block, /batch) but the prose never explains that selection is driven by which parameter you supply, leaving the agent to infer it.

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

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

No annotations are provided, but the description carries substantial behavioral context: read-only nature, cost ($0.01 per call in USDC on Base), the x402 payment mechanism in params._meta["x402/payment"], and the HTTP endpoint. That covers the most critical operational concern (paid access) that annotations would normally handle. It stops short of explaining failure modes or what a verdict contains beyond a 0-100 score.

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 capability list, then pricing and endpoint, which is a sensible order. However, the capability enumeration largely duplicates the sibling tool family and dilutes the tool's actual identity, making it less efficient than a focused verdict description would be.

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 5 parameters, 0 required, no output schema, and no annotations, the description should more fully explain what a verdict actually returns. It gives cost, endpoint, and batch limit but leaves the return shape (beyond a 0-100 score) and error behavior unclear for a paid call.

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

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

Schema coverage is already 80%, but the description adds value by mapping parameters to endpoints (/tx for hash, /block for number, /batch for addresses) and specifying the batch cap of 25 tokens. That endpoint-to-param mapping is not in the schema and helps an agent invoke correctly.

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 broad set of verbs and resources (gas, blocks, balances, tx status, nonces, verdicts), but the tool is named 'verdict' and its siblings include dedicated balance/block/gas/tx/token tools. The description never clarifies what makes 'verdict' distinct from those siblings, so an agent cannot tell which tool to pick.

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 versus when-not guidance despite an extensive sibling family (chainread__balance, chainread__tx, chainread__block, etc.). The free /scan and /t/<address> pages are mentioned but not framed as selection criteria. Routing is left entirely to inference.

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

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

With no annotations provided, the description carries the full behavioral burden and does well: it discloses real matching across all three lists, transliteration of non-Latin names, a 400 error for unscreenable names with no false clear, and x402 payment mechanics. It stops short of rate limits or response structure, but the core behavior is 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?

The description is front-loaded with the purpose and packs useful operational details into a compact paragraph. It is dense but not bloated, though the broad screening menu could be trimmed for sharper focus.

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

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

The description covers purpose, list sources, error behavior, payment, and endpoint, which is substantial given no output schema or annotations. However, it omits return-value structure and never resolves why an address-named tool takes pipe-separated names rather than addresses, leaving a meaningful gap 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 description coverage is 100%, so the schema already explains names, days, and threshold. The description adds only tangential parameter meaning around transliteration and unscreenable names; it does not enrich the semantics of days or threshold beyond the schema.

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

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

The description clearly identifies sanctions screening against OFAC, OFSI, and EU lists, but it does not distinguish this tool from its own siblings check_sanctions__screen, check_sanctions__batch, and check_sanctions__watchlist. By saying it can screen a name, wallet address, batch, or watchlist, it blurs rather than sharpens the specific role of check_sanctions__address.

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 lists what can be screened but gives no explicit guidance on when to use this tool rather than the sibling batch, screen, or watchlist tools. There are no exclusions, prerequisites, or routing conditions to help an agent choose correctly.

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

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

With no annotations present, the description carries the full burden and does so well: it discloses transliteration of non-Latin names, that unscreenable names return HTTP 400 rather than a false clear, the per-call price, the payment rail (USDC on eip155:8453 via x402), and the endpoint. Missing only rate limits and any note on idempotency/partial-batch failure, so not 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?

Dense and front-loaded: covered lists first, then capabilities, then failure mode, then price/endpoint. Every sentence adds something, though the capability enumeration could be trimmed to remove the sibling-overlap confusion, and the HTTP URL at the tail is of marginal use to an agent.

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 is the only place to explain what a batch screening returns – yet it says nothing about per-name match results, threshold scoring output, or how a 400 for one bad name affects the rest of the batch. For a 3-parameter paid batch tool with zero annotations, that leaves a meaningful gap despite the strong cost and failure disclosures.

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 a 3 is the baseline for days/names/threshold. The description earns above baseline by documenting the payment parameter params._meta["x402/payment"], which the schema does not expose at all, plus the 'up to 50' batch limit that complements the names parameter's schema text.

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 the verb (screening), the covered lists (OFAC, OFSI, EU), and enumerates modes, so the resource is clear. But it does not distinguish this tool from siblings like check_sanctions__screen, check_sanctions__address, and check_sanctions__watchlist – it actually lists capabilities ('a name, a wallet address, a batch, or your own watchlist') that those siblings appear to own, blurring the boundary instead of sharpening it. The name implies 'batch' but the prose does not state that batch semantics (up to 50 names) are its differentiator.

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

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

There is no statement of when to prefer this over check_sanctions__screen or check_sanctions__address, nor any exclusion criteria. By claiming it can screen a single name, a wallet, or a watchlist, it arguably competes with its siblings rather than pointing to them, which leaves selection entirely to inference from the tool name.

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

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

With no annotations, the description carries the full burden and does well: it discloses the paid model ($0.01/call in USDC on Base via x402 in params._meta['x402/payment']), the HTTP endpoint, transliteration of non-Latin names, and that unscreenable input returns 400 rather than a false clear. Only the return content of a 'changes' check is left 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?

Dense and front-loaded — lists, matching fidelity, input types, error behavior, and pricing appear in a tight sequence with no filler. The one inefficiency is that the input-type enumeration describes siblings rather than this tool, so the sentences spend space on the wrong thing.

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 should say what a 'changes' result looks like (e.g., newly listed/unlisted matches since the window), and it does not. It is otherwise complete on cost, transport, and error semantics, but the core value proposition of this variant remains unexplained.

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 `days` (default 30, max 400), pipe-separated `names` up to 50, and `threshold` are already documented. The description adds no semantics beyond the schema (e.g., no explanation of what the look-back window means for change detection), 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?

The description states 'sanctions screening' but never explains what makes this tool the 'changes' variant — the look-back re-screening behavior implied by the `days`/`names` params is absent. Worse, it advertises 'Screen a name, a wallet address, a batch, or your own watchlist', which describes the sibling tools (check_sanctions__screen, __address, __batch, __watchlist) rather than this one, leaving the agent unable to distinguish it from four siblings.

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

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

No when-to-use/when-not guidance and no routing to alternatives is given; instead the description lists modalities that belong to siblings, which could actively steer the agent to the wrong tool. The only hint of its unique role (re-screening over a look-back window) comes from the schema, not the description.

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

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

With no annotations, the description carries full behavioral burden. It discloses transliteration behavior, error handling (400 on unscreenable names), pricing ($0.01 per call), payment method (x402 in params._meta), and the HTTP endpoint. This is strong, though rate limits or authentication specifics beyond payment are not mentioned.

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

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

The description is information-dense and front-loaded with the core purpose. Each sentence adds value (sources, inputs, error behavior, pricing, payment, endpoint), though it is slightly long and could be broken into clearer segments.

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

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

Given the tool's complexity (paid API, multiple list checks, error handling) and no output schema, the description provides most needed context for invocation. It omits return value details, but covers payment, error modes, and input flexibility adequately.

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 baseline is 3. The description adds meaning to the 'names' parameter by indicating it can accept a single name, wallet address, batch, or watchlist—information not present in the schema. The other parameters (days, threshold) are fully covered by the schema and need no further explanation.

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 ('screen') and resource ('sanctions screening') and names the three list sources (US OFAC, UK OFSI, EU). It also mentions acceptable input types (name, wallet address, batch, watchlist), but this overlap with sibling tools (check_sanctions__address, check_sanctions__batch, check_sanctions__watchlist) is not clearly differentiated, so it falls short of a 5.

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

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

The description implies usage by listing what you can screen, but it provides no explicit guidance on when to choose this tool over the specialized siblings. There are no exclusions or alternatives named, leaving the agent to infer the correct routing.

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

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

With no annotations, the description carries the full load and does well: it discloses error behavior (unscreenable names return 400, never a false clear), transliteration of non-Latin names, and the exact payment/auth mechanism ($0.01 USDC on Base via x402 in params._meta). It omits return shape, latency/rate limits, and whether screening is logged, so it stops short of a 5.

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

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

Four compact sentences, front-loaded with the core purpose and the strongest differentiator ("real matching on all three"), with price and endpoint at the end where they belong. The address/batch/watchlist clause is the one part that does not earn its place.

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

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

For a 3-parameter screening tool with no output schema and no annotations, the description supplies the critical operational facts: cost, payment protocol and chain, HTTP transport, and the fail-closed error contract. Only the return/verdict format and how `days`/`threshold` affect results are left implicit.

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 names, days, and threshold — baseline 3 applies. The description adds one genuinely useful non-schema detail (the x402 payment location in params._meta) but never explains `days` (the schema calls it "re-screen" look-back) or `threshold`, leaving the two optional tuning knobs understood only from schema text.

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

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

The opening sentence names the specific resource and sources precisely ("Sanctions screening against US OFAC, UK OFSI and EU lists with real matching on all three"), which is more than a restatement of the name. However the follow-up "Screen a name, a wallet address, a batch, or your own watchlist" describes capabilities that clearly belong to the sibling tools check_sanctions__screen / __address / __batch / __watchlist, muddying rather than sharpening what `verdict` itself uniquely returns.

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

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

There is no statement of when to call this versus check_sanctions__screen, __address, __batch, or __watchlist. Worse, the enumeration of name/address/batch/watchlist reads as if this tool covers those cases itself, which borders on misleading given those tools exist as 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?

With no annotations, the description carries the full burden and does so well: it discloses transliteration of non-Latin names, that unscreenable names return HTTP 400 rather than a false clear, the exact price ($0.01 USDC on Base eip155:8453), the payment mechanism (x402 in params._meta), and the raw HTTP endpoint. That is unusually rich operational context for a payment-gated API tool.

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

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

The sanctions scope and safety-critical behavior (no false clear) are front-loaded, and the sentences are dense with useful facts. The trailing pricing and endpoint block runs a bit long, but each element is operationally relevant rather than 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 3-parameter, unannotated tool with no output schema, the description is nearly complete on inputs, cost, and failure modes. The main gap is that nothing describes the shape of a successful screening result (hits, match scores, list provenance), which an agent cannot get elsewhere given output-schema absence.

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 days, names, and threshold are already documented, and baseline 3 applies. The description adds only marginal semantics — noting names are counterparties 're-screened' and implying batch support — without adding 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?

The description opens with a concrete verb and resource ('Sanctions screening against US OFAC, UK OFSI and EU lists') and names the covered lists, which is genuinely informative. However, it then claims the tool can 'Screen a name, a wallet address, a batch, or your own watchlist,' which overlaps heavily with the sibling tools check_sanctions__screen, check_sanctions__address, and check_sanctions__batch, leaving the agent unsure what is distinct about this one.

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

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

There is no explicit when-to-use or when-not-to-use guidance relative to siblings, and the enumerated capabilities (name, address, batch, watchlist) actively blur the boundary with check_sanctions__screen/address/batch. The only differentiating signal is the required 'names' parameter being framed as 're-screen', which 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?

With no annotations, the description carries the full burden and does well: it discloses the price ($0.01/call), the payment rail (USDC on Base, eip155:8453), the exact x402 payment location in params._meta, and the HTTP endpoint. It still leaves out whether a first call establishes a baseline, rate limits, and what happens on fetch failure.

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 tightly written; the pricing and endpoint lines are dense and information-bearing rather than filler. Slightly dense in a single paragraph, but no sentence is wasted.

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

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

For a 6-parameter tool with no output schema and no annotations, the description covers the commercial and return-shape dimensions well. It falls short on the stateful mechanics — what 'stored' vs 'watch' baseline means, what prev_hash does, and what mode controls — which an agent needs to invoke it correctly.

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

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

Schema coverage is only 33%, so the description needs to compensate and does not — it explains none of baseline, prev_hash, mode, or context_lines. The one parameter detail it gives (the x402 payment path) is useful, but the four undocumented parameters leave the semantics of a change-detection call largely unexplained.

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

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

Uses a specific verb and resource ("Monitor public web pages for changes") and states the return contract (changed=true/false plus added/removed lines). It does not distinguish itself from the sibling chgwatch__diffmulti, so an agent must infer the split from names alone.

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

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

"so alert agents pay per poll instead of per page" implies a polling/monitoring use case, but there is no explicit when-to-use or when-not-to-use guidance. Nothing tells the agent when to reach for diffmulti or the webread/web_extract siblings instead.

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

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

With no annotations, the description carries the full load and does well: it discloses the return shape (changed=true/false plus added/removed lines), the payment requirement and network (USDC on Base eip155:8453 via x402 in params._meta), and the HTTP transport. It omits rate limits, error behavior, and whether state persists server-side between polls.

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 purpose and batch scope before pricing and transport details. Pricing/payment detail earns its place given x402, though the raw endpoint URL is filler for an agent already holding the tool binding.

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

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

No output schema, and the description does compensate by describing the diff response, so an agent knows what comes back. But with no annotations and four undocumented parameters including two behavior-defining enums, an agent still cannot confidently construct a correct call from the description alone.

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 only 33% — only 'urls' and 'url' are documented in the schema. The description explains no parameters at all, leaving the semantically loaded enums (mode: text/markdown/meta/links, baseline: stored/watch) and prev_hash/context_lines undefined anywhere, and 'baseline' in particular determines whether a diff is even possible.

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 ('Monitor public web pages for changes') and immediately scopes the batch variant with 'One call checks many URLs', which lets an agent separate it from the single-URL sibling. It never names chgwatch__diff explicitly, so differentiation is inferential rather than stated.

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

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

'so alert agents pay per poll instead of per page' gives a cost-based rationale for batching, which implies when to pick this over per-page polling. However, there is no explicit 'use chgwatch__diff for a single URL' routing, and no exclusions or prerequisites (auth, rate limits) are 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?

With no annotations, the description carries the full burden and does well: it discloses sourcing (public records only), a privacy boundary ('no personal data'), cost ($0.01 USDC on Base, eip155:8453), the x402 payment parameter location, and the transport (HTTP GET). It omits failure behavior (no-match, upstream errors) and latency, keeping it below a 5.

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

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

Densely front-loaded: the payload contents come first, then the privacy note, then the price/payment mechanics and endpoint. Every sentence carries information, though the payment boilerplate is a bit compressed against the substance.

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 lookup with no output schema and no annotations, the description covers what is returned, what is excluded, what it costs, and how to pay. The remaining gap is result shape and not-found behavior, which matters because there is no output schema to fall back on.

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

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

Only one parameter and schema coverage is 100%, including the 'q' alias, so the schema already does the work. The description adds nothing about the company string itself (normalization, ambiguity, partial names), making the baseline 3 correct.

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

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

States a specific resource — 'one joined company dossier' — and enumerates its parts (SEC EDGAR identity, CIK, SIC, incorporation state, filings, RDAP domain facts, sanctions screen), so an agent knows exactly what comes back. It does not distinguish itself from near-neighbors like company_facts__snapshot, composite__brief, or edgar__company, so it falls short of a 5.

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

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

Nothing says when to pick this over the many overlapping siblings (edgar__company, check_sanctions__screen, domfacts__rdap, composite__brief). The only invocation guidance is mechanical — price and how to pay — not selection guidance or exclusions.

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

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

With no annotations at all, the description carries the full burden and does meaningful work: it discloses a per-call price ($0.01 USDC on Base, eip155:8453), the x402 payment mechanism and the exact param location (params._meta["x402/payment"]), the HTTP method and endpoint, and a 'no personal data' data-handling claim. It leaves gaps on rate limits, failure/empty-result behavior, and whether the sanctions hit is fuzzy or exact — hence not a 5.

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

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

Three dense but purposeful sentences, front-loaded with what the caller gets, then cost/payment, then transport. No filler and each clause maps to a decision the agent must make before calling.

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

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

No output schema and no annotations, so the description must cover both shape and behavior; it does so by listing the returned fact categories and the payment precondition. It stops short of describing response structure, per-source failure handling, or result size, which matters for an aggregate dossier.

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

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

Only one parameter, and the schema already documents it at 100% coverage, including the 'q' alias. The description adds no syntax, normalization, or matching-behavior detail (e.g. exact vs fuzzy name matching) beyond what the schema states, so this is the baseline 3.

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

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

The description names a specific resource (a joined company dossier) and enumerates exactly what it contains: SEC EDGAR identity/CIK/SIC/incorporation state, recent filings, RDAP domain facts, and an OFAC/UK/EU sanctions screen. That composition tells an agent precisely how this differs from narrower siblings like company_facts__lookup, edgar__company, domfacts__rdap, or check_sanctions__screen.

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

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

Usage is only implied: the phrase 'One joined company dossier' signals this is the aggregate/one-shot alternative to the single-source siblings, but no explicit when-to-use or when-not-to-use guidance is given. An agent must infer that the $0.01 price and bundling make this preferable when multiple data facets are needed at once.

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

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

With no annotations, the description carries the full burden and does well: it discloses that the call is paid ($0.01 USDC on Base), where payment goes (params._meta['x402/payment']), and the HTTP transport. It does not describe failure behavior when payment is missing or rate/limit constraints, leaving a modest gap.

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 tightly packed sentences: capability first, value proposition second, payment and endpoint last. No filler, and the most decision-relevant information is front-loaded.

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

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

There is no output schema, so the description correctly enumerates the returned sections and explains the payment mechanism an agent must supply. Response shape detail (field names, pagination, null handling) is absent, which is a minor gap for a composite aggregation tool.

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

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

Schema description coverage is 100%, so both 'q' and 'excerpts' are already well documented in the schema. The description adds no syntax details for 'q' (ticker/name/CIK) or ranges for excerpts, 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 ('joins public SEC EDGAR data into an agent-ready brief') and enumerates the bundled payload: profile, financial series with YoY and margins, filings, risk excerpts. This clearly distinguishes it from single-focus siblings such as edgar__company, edgar__financials, and composite__filings.

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 line 'Saves an agent five separate lookups and all the parsing' gives a clear condition for preferring this tool over the individual EDGAR lookups. It stops short of explicitly naming which siblings it replaces or when not to use it (e.g., when you only need filings), so it falls just short of full routing guidance.

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

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

With no annotations, the description carries the full burden and does well on the hard parts: it discloses a concrete cost ($0.01 per call in USDC on Base, eip155:8453), the exact payment mechanism (x402 in params._meta["x402/payment"]), and the transport (POST endpoint). What it omits is failure behavior — what happens if payment is missing or the ticker is ambiguous — and any latency/size expectations for a multi-source join.

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 value proposition and output contents, then a separate short sentence for payment mechanics — a sensible split. It is dense but every clause conveys something usable; the only soft spot is that the pricing/endpoint detail crowds the same block as the capability statement.

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

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

There is no output schema, so the description must describe returns — and it does, enumerating the four content areas with concrete financial metrics. Cost and payment wiring are covered, which is essential for an x402 tool. Missing only edge-case behavior and any note on data freshness, which keeps it short of a 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 description coverage is 100%: 'q' is documented as ticker/name/CIK with three examples and 'excerpts' as a 0-10 bound, so the schema already does the work. The description reinforces the excerpt concept by listing 'risk-factor excerpts' among the outputs but adds no 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+resource (joins public SEC EDGAR data into a brief) and enumerates exactly what comes back: company profile, annual financial series with YoY growth and margins, recent filings, and risk-factor excerpts. It is clearly a broader aggregation than a single-lookup tool, but it never names which sibling it replaces (edgar__company, edgar__financials) or how it differs from composite__brief, so the differentiation is inferred rather than stated.

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

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

"Saves an agent five separate lookups and all the parsing" implies the case for using it over piecemeal EDGAR calls, which is a real usage signal. However there is no explicit when-to-use/when-not, no naming of the alternatives, and no guidance on when a narrower call (e.g. a single financials lookup) would be cheaper than paying $0.01.

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

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

With no annotations, the description carries the full burden and does well on the two surprising traits: it states the cost ($0.01/call in USDC on Base eip155:8453) and the exact payment placement in params._meta["x402/payment"], plus the HTTP transport. It doesn't cover error/failure behavior when payment is missing, rate limits, or freshness of the EDGAR data, which keeps it below a 5.

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

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

Front-loaded with the payload contents before cost and transport, and every sentence carries information. The middle sales clause ("Saves an agent five separate lookups") is partly puffery, and the full URL plus CAIP-2 chain ID inline makes one very long sentence, but 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?

No output schema and no annotations, so the description must define the return surface — and it does by enumerating the four data blocks returned. What's missing is any sense of response shape (flat text brief vs. structured object), size/latency expectations, or behavior when a ticker has no EDGAR match.

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 both parameters (q, excerpts) are self-documenting with examples, so the baseline is 3. The description does add one thing the schema omits — that a payment object lives in params._meta — but gives no guidance on the excerpt count tradeoff or on q's resolution ambiguity (ticker vs. name vs. CIK).

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 concrete verb+resource (joins SEC EDGAR data into a brief) and enumerates exactly what the brief contains: profile, annual financial series with YoY growth and margins, recent filings, risk-factor excerpts. However it never differentiates itself from near-identical siblings like composite__brief, edgar__financials or company_facts__snapshot, and the tool name 'watchlist' actively misleads about the resource, so an agent could easily pick the wrong tool.

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

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

"Saves an agent five separate lookups and all the parsing" gives a clear selection rationale: use this when you'd otherwise fan out to multiple lookups. There are no explicit exclusions and no sibling is named as the cheaper alternative for a single-field need.

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

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

With no annotations, the description carries the full burden and does well: it discloses a concrete price ($0.01/call in USDC on Base, eip155:8453), the x402 payment path (params._meta["x402/payment"]), the HTTP method and endpoint, and which endpoints are free vs paid. It stops short of failure behavior, rate limits, or result format, so it is strong but not exhaustive.

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

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

The capability list is front-loaded in the first clause and the commercial terms follow in a compact second block with zero filler. It is dense but every clause (checks, free sample, price, payment field, endpoint) 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 no-annotation, no-output-schema tool, the definition covers cost, payment, and report contents, which are the highest-risk unknowns. It is still incomplete on how the two parameters map to the three advertised endpoints and what an agent gets back (or what happens when payment is absent), which matters for a paid 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 both parameters are already documented in the schema, and this is the baseline case. The description only reinforces the 'domains' parameter by stating '/batch up to 10 domains'; it adds no format, delimiting, or validation detail beyond what the schema provides, and says nothing about how 'domain' vs 'domains' interact.

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

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

The description uses a specific verb+resource framing ('Trust check for any domain') and enumerates exactly what is checked (DNS, SPF/DMARC/DKIM, WHOIS, HTTP status, TLS/HSTS). However, it bundles three endpoints (/preflight, /dns, /batch) into one definition, so it never makes clear whether this tool is the batch entry point or a general domain-intel tool, and it never distinguishes itself from the sibling domain_intel__dns.

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 hints at alternatives by mentioning the free /preflight sample and paid /dns full report versus /batch up to 10 domains, which implies a cost/volume choice. But it never states when an agent should pick this tool over domain_intel__dns, nor whether the 'domain' parameter routes to a single-domain mode — usage is left to inference.

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

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

With no annotations at all, the description carries the full burden and does a lot of it: cost ($0.01/call), currency and chain (USDC on Base, eip155:8453), the exact payment channel (x402 in params._meta["x402/payment"]), a free sample path, and the concrete endpoint URL. This is exactly the kind of auth/cost context annotations would otherwise supply. It omits failure modes, rate limits, and what a successful paid response looks like.

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 payoff in the first clause, then pricing and transport in compact lines. Every element is substantive. It is dense to the point of being run-on in the pricing sentence, where USDC/Base/eip155/x402 are packed together without separation, but nothing is genuinely expendable.

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 2-param, no-output-schema tool with no annotations, the description covers what is checked, what it costs, how to pay, and where it lives. The remaining gap is call mechanics: with zero required params, an agent cannot tell from the description which argument selects /preflight versus /dns versus /batch.

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 both params are already documented in-schema, so baseline applies. The description adds only that /batch tops out at 10 domains — a constraint the schema also repeats — and never clarifies that 'domain' addresses /preflight or /dns while 'domains' addresses /batch. Notably both params are optional, and the description gives no indication of which one is needed for which path.

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 ('Trust check for any domain') and enumerates the exact data classes returned: DNS, SPF/DMARC/DKIM, WHOIS registrar/age, HTTP status, TLS issuer/expiry, HSTS. That is far more specific than a tautology. It does not, however, distinguish itself from adjacent siblings like domfacts__dns, domfacts__rdap, or domain_intel__batch, which an agent could reasonably confuse it with.

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

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

It gives real selection context within the tool: free /preflight for a sample, paid /dns for the full report, /batch for up to 10 domains, plus the price. What it never says is when to pick this over domain_intel__batch or domfacts__dns, nor what the prerequisites are for x402 payment to succeed. Usage is implied by the endpoint/pricing breakdown rather than stated as guidance.

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

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

With no annotations at all, the description carries the full burden and does a lot of work: it discloses the exact price ($0.01 USDC on Base, eip155:8453), the payment mechanism (x402 via params._meta["x402/payment"]), and the underlying HTTP endpoint. That is meaningful behavioral context an agent needs before calling. It loses a point for omitting failure behavior (invalid or missing domain), since domain is not even required.

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

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

The capability statement is front-loaded and dense with useful specifics; the pricing and endpoint tail is compact. The middle RDAP clause is slightly run-on, but no sentence is wasted.

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

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

Given no annotations, no output schema, and 0% schema coverage, the description does partially compensate by enumerating the returned fact categories (registrar, created/expiry dates, domain age, days to expiry, nameservers, EPP status) and the payment requirement. However, it never covers the optional-domain case or error/empty-result behavior, which matters because required parameters is 0.

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

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

Schema coverage is 0% and the single parameter has no description in the schema, so the description must compensate. It only implies the parameter via "for any domain" and adds no syntax, format, or subdomain guidance. Marginal but non-zero value over the bare schema.

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

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

The description states a concrete verb-and-resource pair: it returns DNS records for the enumerated types (A, AAAA, MX, TXT, NS, CNAME, SOA, CAA) plus RDAP registration facts (registrar, dates, nameservers, EPP status). That is much more specific than a title restatement. It stops short of a 5 because the RDAP half of its scope overlaps domfacts__rdap and it never acknowledges which of the two siblings to prefer.

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

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

There is no explicit when-to-use or when-not-to-use guidance, and no reference to the closely related siblings domfacts__rdap or domain_intel__dns. An agent must infer from the record-type list alone that this is the DNS-lookup entry point rather than the RDAP-only or batch entry point.

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

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

With no annotations, the description carries the full burden and does substantial work: it discloses the exact cost ($0.01 USDC on Base eip155:8453), the payment mechanism and the parameter path (params._meta["x402/payment"]), and the underlying HTTP method and URL. It omits failure modes, output format, and whether payment is taken on error, 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?

One dense sentence, front-loaded with the returned data, followed by cost and transport details in priority order. No filler, though the compact packing of pricing and URL into the same sentence slightly blurs the distinction between description and invocation metadata.

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 lookup with no output schema, the description covers what is returned, what it costs, and how the payment is supplied — enough to call it correctly. The remaining gap is input format for 'domain', which is the one thing an agent could still get wrong.

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

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

Schema coverage is 0% and the single 'domain' parameter has no description or type detail beyond 'string'. The description only says 'for any domain', which does not clarify expected format (bare domain vs. scheme/URL, subdomain handling, IDN) or whether it is optional at runtime despite 0 required parameters.

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

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

The description names the specific resource (DNS records plus RDAP registration facts) and enumerates the record types and fields returned, so an agent knows exactly what it gets. It is not explicitly distinguished from domfacts__dns or domain_intel__dns, but the combined DNS+RDAP scope implicitly separates it from the DNS-only siblings.

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

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

Usage is only implied: an agent can infer this is the tool for looking up a domain's records and registration data, and the pricing/payment note tells it what a call costs. There is no explicit when-to-use, when-not, or named alternative (e.g., domfacts__dns for DNS alone), so routing between the near-identical siblings remains guesswork.

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

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

With no annotations provided, the description carries the full load and does disclose critical behavior an agent would otherwise miss: a $0.01 per-call cost in USDC on Base (eip155:8453), the x402 payment payload location (params._meta["x402/payment"]), and the underlying HTTP endpoint. It stops short of describing error behavior, empty-tag responses, or rate limits, which matters for a paid call.

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 run-on sentence followed by pricing and endpoint metadata, and it also carries a truncated-text artifact ("si…[29 more chars, already applied]"), which reads as an editing leak. The pricing and payment details earn their place, but the marketing framing and missing delimiter structure cost it.

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

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

For a 4-parameter paid lookup with no annotations and no output schema, the definition covers payment and endpoint but omits what a successful response contains and how tag/period/limit interact (e.g., whether tag absence returns profile only). Adequate for calling, incomplete for predicting results.

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

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

Schema description coverage is 100%, including examples for q (AAPL, nvidia, 320193), an alias list for tag, and enum for period, so the baseline is 3. The description adds no syntax or semantics beyond restating example tags already in the schema.

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

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

The description opens with a service-level pitch ("Public SEC EDGAR data for agents") and then lists a bundle of capabilities: company profile, recent filings, XBRL history, and full-text search. Only "company profile plus recent filings" maps cleanly to this tool, while the XBRL and full-text-search claims overlap sibling tools (edgar__financials, edgar__search) without any differentiation. An agent can guess the resource, but not the precise scope.

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

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

There is no statement of when to use this tool versus edgar__financials, edgar__resolve, or edgar__search, despite the description claiming capabilities those siblings appear to own. The only conditional guidance is about payment mechanics, not tool selection.

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

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

No annotations exist, so the description carries the full behavioral burden. It does add genuinely useful context beyond the schema: the $0.01 USDC-on-Base price via x402 and the exact payment key location (params._meta['x402/payment']) and HTTP endpoint. However, it says nothing about read-only semantics, rate limits, error behavior, or what the response looks like.

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

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

The capability list is front-loaded but reads as a run-on enumeration cramming profile, filings, XBRL, and full-text search into one clause. Pricing and HTTP details are useful since they have no structured home, but the whole thing is dense and the trailing truncation suggests padding.

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

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

For a four-parameter, multi-mode tool with no output schema and no annotations, the description should clarify how callers switch between profile, filings, and XBRL modes and what each returns. It never explains the mode-selection logic or return shape, leaving meaningful gaps for what is effectively several tools in one.

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 documented in the schema, establishing a baseline of 3. The description gives a few tag aliases (revenue, net income, assets) that echo the schema's own examples, adding only marginal value and no interaction semantics between `q` and `tag`.

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 resource (SEC EDGAR data) and enumerates three capabilities (company profile, filings, XBRL history, full-text search), so the surface area is visible. But it bundles multiple distinct operations into one tool without indicating which parameter selects which mode, and it overlaps heavily with siblings named edgar__company, edgar__search, and edgar__resolve without distinguishing itself from 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?

There is no statement of when to use this tool versus edgar__company, edgar__search, edgar__resolve, or company_facts__lookup, all of which appear to cover adjacent ground. The reader is left to infer that supplying a `tag` triggers XBRL history while omitting it produces a profile, but that is never 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?

With no annotations, the description carries the full behavioral burden. It does disclose important context—paid x402 access, $0.01 per call in USDC on Base, and the payment parameter location—but it does not state that the operation is read-only or describe what the response contains.

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

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

The description front-loads the data-domain context, but it then piles several capabilities, a price, and an HTTP endpoint into a dense block. It is not excessively long, but some phrasing serves service marketing rather than tool selection.

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

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

Given four parameters, no output schema, and no annotations, the description should clarify what a call returns and how q, tag, limit, and period interact. Instead it broadly advertises three capabilities, leaving the agent unsure whether a single call returns filings, financials, search results, or all of them.

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 explains q, tag, limit, and period. The description adds no parameter-level meaning 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?

The description lists several capabilities ('company profile plus recent filings', 'XBRL financial history', 'full-text search') but does not explain what 'resolve' itself does or how it differs from the sibling tools edgar__company, edgar__financials, and edgar__search. An agent can infer it is an EDGAR data endpoint, but cannot easily tell which specific operation this tool performs.

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

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

The description gives no guidance on when to use this tool versus the three similarly named EDGAR siblings. It only states payment and HTTP details, leaving the selection decision entirely to the agent's guesswork.

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

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

No annotations are provided, so the description must carry the behavioral load. It does disclose real, useful context beyond the schema: the $0.01/call USDC-on-Base price and the x402 payment requirement via params._meta, plus the HTTP endpoint. But it omits rate limits, failure behavior, and, with no output schema, the shape of the returned data, leaving meaningful gaps for a paid search tool.

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

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

The data capabilities are front-loaded and reasonably tight, but the fixed x402/price/HTTP boilerplate consumes nearly half the text and is repeated identically across tools. Nothing is grossly wasted, but the payment metadata crowds out capability and differentiation detail.

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

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

For a 4-param, no-output-schema, no-annotation, paid tool, the description covers what data is returned and how payment works, which is the minimum. It still lacks sibling differentiation and any hint of the response structure, so an agent has enough to call it but not enough to choose it confidently or anticipate its output.

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

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

Schema coverage is 100%, so each of the four params is already documented with examples and an enum. The description's mention of tags (revenue, net income, assets) merely restates the tag param's schema description, adding no new syntax or semantics. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The verb+resource ('full-text search across EDGAR filings') is specific, and the enumeration of capabilities (profile, filings, XBRL financial history) tells an agent roughly what data comes back. However, those same capabilities are the whole purpose of the sibling tools edgar__company and edgar__financials, and the description never clarifies what this umbrella 'search' does differently. An agent cannot confidently distinguish it from its siblings.

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

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

There is no statement of when to use this tool versus edgar__company, edgar__financials, or edgar__resolve, and no exclusions or prerequisites. The description lists capabilities but leaves the choice among overlapping siblings entirely to inference.

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

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

With no annotations present, the description carries the full burden and does substantial work: it discloses the 12-source cap, the bundled 22 curated working feeds, the $0.01 USDC-on-Base cost, the x402 payment mechanism via params._meta, and the HTTP endpoint. It stops short of covering failure modes, partial-source failure handling, or rate limits.

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

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

The function is front-loaded in the first clause and the payment/endpoint metadata is appended compactly. It is dense but every clause carries information; the only minor cost is that pricing and transport details sit in the same sentence as the capability statement.

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 four-parameter tool with no annotations and no output schema, the description supplies the return fields, source limits, cost, and payment protocol. An agent could call this correctly without further research; only error and pagination behavior remain unaddressed.

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

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

Schema description coverage is 100%, so each of the four parameters is already documented, establishing the baseline of 3. The description reinforces the 12-source ceiling and hints that sources can be curated, but adds no syntax or format detail beyond what the schema states.

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

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

States a specific verb and resource: merges up to 12 public RSS/Atom/JSON feeds, dedupes, filters by keyword and recency, and returns one ranked list. The output shape (title, link, time, summary) is spelled out, so an agent knows exactly what it gets. No sibling tool competes in this domain, so differentiation is trivially satisfied.

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 operational flow (merge, dedupe, filter, rank) implies when to use it, but there is no explicit statement of when to prefer it over alternatives such as websearch__brief, nor any exclusion criteria. Usage is inferable rather than directed.

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

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

With no annotations, the description carries the full load, and it does supply genuinely useful operational context: paid access at $0.01/call in USDC on Base, x402 payment placed in params._meta, a free /sample, and the raw HTTP GET endpoint. It does not disclose what the response looks like, error behavior for unsupported symbols, or how 'best' is ranked, so it falls short of a complete behavioral picture for a paid tool.

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

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

Front-loaded with the resource and scope, then payments and endpoint; nearly every clause carries information. The pricing/URL tail is dense but relevant to actually invoking a paid x402 endpoint.

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?

Sources, normalization, pricing, payment mechanism, and endpoint are all covered, and no output schema exists to explain return values. But the meaning of 'best' and the semantics of `symbols` — the two things an agent most needs to call this correctly — are left 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 description coverage is 0% and the single `symbols` parameter is undocumented — no format (comma-separated string vs. multiple values), no indication that it is optional, and no statement of what happens when it is omitted (all symbols?). The description adds no meaning beyond the bare schema.

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

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

The description states a specific resource (perpetual funding rates), names the seven venues, and specifies the normalization (8h, annualized). However, it never explains what 'best' selects — presumably the best venue per symbol — which is the tool's defining behavior and its only distinction from fundinglens__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?

It mentions a free /sample and the per-call price, which hints at a try-before-buy pattern, but gives no explicit when-to-use guidance and never routes the agent to or away from the closely named siblings fundinglens__rates and funding_rates__best.

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

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

With no annotations at all, the description carries the full burden and does real work: it discloses the price ($0.01/call in USDC on Base), the exact payment mechanism (x402 in params._meta["x402/payment"]), and the HTTP method and endpoint. It does not disclose rate limits, failure modes, or response shape.

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?

Dense and front-loaded: data source and normalization come first, payment and transport details follow. No filler sentences, though the payment/HTTP tail is somewhat crammed into the same breath as the data description.

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 tool with no output schema, the coverage of sources, normalization and billing is adequate. The gaps are the one thing that matters most for invocation — how to specify symbols and what the response looks like.

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

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

Schema coverage is 0% for the single parameter, so the description must compensate — and it never mentions 'symbols'. It gives no indication of format (comma-separated? repeated?), whether omission returns all symbols, or how symbols map to the 7 venues.

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?

A specific verb-plus-resource statement: perpetual funding rates, with the 7 named venues and the normalization (8h, annualized) spelled out. It is clear on its own, but it does not distinguish itself from near-identical siblings such as fundinglens__best or funding_rates__rates, which an agent would need to choose between.

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 'Free /sample' hint implies a trial path before paid use, which is useful context. But there is no explicit statement of when to use this versus fundinglens__best or funding_rates__rates, and no exclusion criteria.

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

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

No annotations are provided, so the description carries the full load, and it does well: it discloses the paywall ($0.01/call, USDC on Base eip155:8453), the x402 payment mechanism via params._meta['x402/payment'], and the HTTP GET endpoint. These are exactly the non-obvious traits an agent needs before invoking. It omits return shape and whether the call is read-only, but read-only is evident from 'public market-data APIs'.

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 dense sentences that front-load the purpose before the pricing and payment mechanics—every element earns its place for correct invocation. Slightly packed, but no filler.

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

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

With no output schema and no annotations, the description must convey the essentials, and it covers the critical payment/auth path fully. It leaves the 'batch' scope and the return format unexplained, but for a one-param paid read that 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 coverage is 100% and the single 'symbol' param is documented ('Asset symbol, e.g. BTC'). The description's 'BTC, ETH, SOL and more' hints at coverage breadth but adds no syntax or format detail beyond the schema. Baseline 3 is appropriate when the schema does the work.

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 (perpetual-futures funding rates and annualized carry) and source (exchange public market-data APIs), so the agent knows what it returns. However, it never distinguishes itself from the six sibling tools in the funding/fundinglens family (rates, funding, best, history), and 'batch' is confusing since the schema takes a single symbol. Clear purpose but no sibling differentiation.

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

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

No guidance on when to use this versus funding_rates__rates, funding_rates__funding, funding_rates__best, or the fundinglens equivalents. The only implied usage is the 'batch' in the name, which the single-symbol schema contradicts. The agent must guess the routing.

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

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

With no annotations, the description carries the full burden and does disclose the non-obvious operational facts: a $0.01 USDC charge on Base, x402 payment passed in a params._meta key that is not declared in the schema, and the HTTP endpoint. It stops short of saying what 'best' selection logic is, the freshness/cadence of the data, or what happens on an unpaid call.

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 capability before the commercial and transport details. Every clause carries information (coverage, price, payment mechanism, endpoint), though the coin list 'and more' is slightly wasteful.

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 tool with no annotations or output schema, the description covers cost, payment, and transport well, but leaves the central semantic gap: what 'best' means (best rate across venues? highest carry?) and what the response contains. An agent can invoke it, but cannot confidently predict or frame the result.

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

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

Schema coverage is 100% and the sole declared parameter (symbol) is already documented, so the baseline is 3. The description earns above baseline by surfacing a required-but-undeclared payment parameter (params._meta["x402/payment"]) that the schema does not mention at all — without that sentence an agent would fail its first paid call.

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 and what is returned: perpetual-futures funding rates plus annualized carry for BTC/ETH/SOL, sourced from exchange public market-data APIs in one call. The scope is clear, but nothing distinguishes it from close siblings such as funding_rates__rates, funding_rates__funding, or fundinglens__best — the word 'best' is never explained (best across exchanges? lowest rate?).

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

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

Usage is only implied: the agent can infer 'call this when you want funding rates for one asset', and the mention of a free /preflight sample hints at a trial path before paying. There is no explicit when-to-use versus funding_rates__batch/history or fundinglens__best, and no stated prerequisites beyond payment.

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 zero annotations, the description carries the full burden and does disclose the highest-value behavioral facts: this is a paid call at $0.01 USDC on Base (eip155:8453), payment travels in params._meta["x402/payment"], and a free /preflight sample exists — all material auth/cost context an agent must know before invoking. It falls short of 5 because it says nothing about failure modes (unknown symbol, upstream exchange outage) or rate limits.

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

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

Three tight sentences, front-loaded with what the tool returns and where the data comes from, followed by the commercial/payment terms and the raw endpoint. Nothing is repeated and no sentence is filler.

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

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

For a one-parameter read tool with no annotations and no output schema, the description covers cost, payment mechanism, data source and endpoint, which is a lot. The remaining gap is the return payload: 'annualized carry' is named but not characterized (per-exchange rows? a single aggregate?), and on a paid call an agent benefits from knowing roughly what it is buying.

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

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

Schema coverage is 100% for the single `symbol` parameter, so the baseline is already high. The description adds modest value beyond the schema by enumerating supported assets ('BTC, ETH, SOL and more'), which tells the agent the symbol vocabulary is a known asset ticker rather than an arbitrary string or pair like BTCUSDT.

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: perpetual-futures funding rates plus annualized carry, sourced from exchange public market-data APIs, in a single call. It does not, however, differentiate itself from the many siblings in the same family (funding_rates__batch, __best, __history, __rates, fundinglens__rates), so an agent cannot tell from the description alone why it would pick this single-symbol variant over the others.

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

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

There is no explicit when-to-use or when-not-to-use guidance, and the siblings are never named. The 'Free /preflight sample' line implies a trial path but does not say under what conditions an agent should take it versus paying for a call.

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

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

With no annotations, the description carries the full burden and discloses important behavioral context: the data comes from exchange public market-data APIs, there is a free preflight sample, and calls cost $0.01 USDC on Base via x402 payment in params._meta. It does not mention rate limits, historical window, or response shape, but the payment and data-source transparency is strong.

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

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

The description is front-loaded with the core purpose, followed by pricing, payment, and endpoint details. It is dense but every sentence adds operational value for an agent that must know cost and access mechanics.

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 tool with no output schema, the description covers purpose, source, and payment well. However, it leaves ambiguity about what 'history' means (time range, granularity) and what the response contains beyond funding rates and annualized carry, which an agent may need before relying on it.

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

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

Schema coverage is 100%, and the single symbol parameter is already documented in the schema as an asset symbol. The description adds a small amount of context by naming BTC, ETH, and SOL as supported examples, but provides no additional parameter syntax or constraints beyond the schema.

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

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

The description states a specific resource (perpetual-futures funding rates and annualized carry) and scope (BTC, ETH, SOL and more, one call). It is clear what the tool returns, but it does not explicitly distinguish itself from siblings like funding_rates__rates, funding_rates__batch, or fundinglens__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?

The description mentions a free /preflight sample and pricing, but gives no guidance on when to use this tool instead of sibling funding-rate tools such as funding_rates__batch or funding_rates__best. No exclusions or alternative-selection criteria are provided.

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

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

With no annotations at all, the description carries the full load and does well on the highest-risk trait: it discloses the paid model ($0.01/call in USDC on Base, x402 payment supplied via params._meta) and the raw HTTP endpoint, which an agent must know before invoking. It omits return-value structure, error behavior for an unsupported symbol, and whether rates are aggregated across exchanges, so it stops short of 5.

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

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

Two tight sentences plus endpoint metadata, with the purpose front-loaded and payment terms immediately after. Every clause carries information an agent needs: scope, sample availability, price, payment channel, and transport.

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 tool with no annotations and no output schema, the description covers purpose, cost, payment mechanics, and endpoint. The remaining gap is return shape and per-exchange granularity, which with no output schema the description could have sketched in a clause.

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 single 'symbol' parameter is already documented with an example, making 3 the baseline. The description's 'BTC, ETH, SOL and more' adds a small amount of coverage signal about supported assets but says nothing about validity rules or casing beyond the schema's example.

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 and verb-like outcome: perpetual-futures funding rates and annualized carry for named assets from exchange public APIs. An agent knows exactly what data comes back. It does not, however, differentiate itself from the closely named siblings (funding_rates__batch, __best, __funding, __history), so the sibling-disambiguation bonus is missing.

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?

'In one call' and the mention of a free /preflight sample imply this is the single-symbol entry point and that you can trial it before paying, but there is no explicit statement of when to use this versus funding_rates__batch or __history. Usage is inferable from the sibling names 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?

With no annotations, the description carries the full burden and does disclose meaningful behavior: the call is free, while listed tools are billed per call via x402 in USDC on Base. That pricing/cost model is exactly the kind of context an agent needs before proceeding. It does not describe the response shape or any rate limits, so it isn't exhaustive.

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 waste, with the cost-relevant fact ('Free.') front-loaded before the enumeration and the payment model. Every clause adds 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 no-parameter read tool with no output schema, the description covers what is returned at a field level (name, description, price, HTTP paths, MCP tools, OpenAPI document) and the payment context. Minor gap: it doesn't indicate whether the OpenAPI document is inline or by reference, or how an agent should act on the x402 billing info.

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 tool takes zero parameters and the schema is empty with additionalProperties=false, so there is nothing for the description to disambiguate. Baseline for a 0-param tool 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 ('Lists the paid services on this server') and enumerates exactly what each entry contains: name, description, price, HTTP paths, MCP tools and OpenAPI document. That is far more precise than the name alone. It doesn't name a sibling to differentiate from, which keeps it short of a 5.

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

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

Implicitly a discovery/catalog tool – an agent can infer it should be called before invoking paid tools to learn their prices and paths. However, there is no explicit 'use this when…' or 'do not use for…' statement, and no sibling is named as an alternative.

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

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

With no annotations, the description does carry real behavioral weight: it discloses the exact price ($0.01 USDC on Base/eip155:8453), the x402 payment mechanism and where the payment goes (params._meta['x402/payment']), and the underlying HTTP endpoint. It does not cover failure modes (non-public or unreachable pages), rate limits, or what a 'link health' result or 'change' signal actually contains.

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?

Purpose and output inventory are front-loaded, with payment and transport details appended, and there is no filler. The single sentence is somewhat run-on and the trailing 'change…' fragment is clipped, slightly hurting readability.

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

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

There is no output schema, so the description must carry return-value semantics; it does enumerate the returned artifacts, which is the main thing an agent needs. However the truncated 'change…' element is left undefined, and nothing is said about errors, payment failure handling, or result size beyond the markdown cap.

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 ranges, defaults and formats are already handled by the schema. The description only hints at parameter behavior indirectly ('link health checks', 'clean markdown'), adding no syntax or tradeoff guidance such as when to raise check_links or max_markdown_chars.

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 first clause names a specific verb and resource ('full picture of a web page') and enumerates concrete outputs: markdown, metadata, heading outline, link census, link health. It implicitly distinguishes itself from the narrower siblings (webread__read, webread__meta, webread__outline) by being the combined call, though it never names 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?

'One call' implies this is the aggregated alternative to the single-purpose siblings, which is useful implied usage guidance. But there is no explicit when-to-use/when-not, no statement of prerequisites (e.g. public pages only), and no named alternative for lighter-weight needs.

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

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

With no annotations, the description steps up well: it discloses the paid-call model, the price ($0.01 USDC), the settlement chain (Base, eip155:8453), the x402 mechanism and the exact payment parameter (params._meta["x402/payment"]), plus the underlying HTTP endpoint. It does not cover rate limits, whether the free preview differs in fields, or what happens on insufficient payment.

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

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

The capability and price lead, followed by the payment mechanics and endpoint. It is dense and mostly front-loaded, though the mixing of marketing ('Free preview') with payment plumbing in one sentence slightly muddies the scan.

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

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

There is no output schema and no annotations, so the description must carry the full burden. It does describe the report's contents well, but leaves the batch-vs-single ambiguity unresolved and gives no sense of result shape, error behavior, or how the preview differs from the paid report.

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 50%: `chain` is constrained by an enum and `address` is documented as a 0x-prefixed contract address, so the schema carries most of the load. The description adds nothing about parameter semantics and notably fails to clarify how a tool named 'batch' relates to the single chain/address input.

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 ('Token due-diligence report for any Base/ETH/BSC/Arbitrum token') and enumerates the report contents (price/liquidity, honeypot, mint authority, tax, holder concentration, supply checks, verdict). This clearly separates it from generic chain-read or price siblings. However, the 'batch' in the name is never explained, and the schema accepts a single chain+address, leaving the agent unsure what 'batch' means relative to token_dd__check.

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 rather than explicit: 'Free preview; full report $0.01' tells the agent there are tiers and a cost, but it never says when to pick this over token_dd__check or basedue__report. There are no stated exclusions or prerequisites beyond the payment detail.

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

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

With no annotations, the description carries the behavioral burden and does useful work: it discloses the free preview / paid full report model, the exact per-call price, the payment rail (USDC on Base via x402), and the HTTP endpoint. It does not cover rate limits, error behavior, or response shape, but the pricing and payment mechanics are unusually transparent.

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

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

The description is dense but front-loaded: report scope comes first, followed by pricing/payment and endpoint information. Every clause conveys operational detail, 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 data-retrieval tool with no output schema and no annotations, the description does well by enumerating what the report includes and how payment works. It stops short of describing the response structure or failure modes, which 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 coverage is 50%, so the description has to add value. It names the supported chains and, importantly, documents the x402 payment field in params._meta, which is not represented in the input schema but is required for invocation. It does not expand on the address format beyond what the schema already says.

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

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

The description states a specific verb and resource: a token due-diligence report covering price, liquidity, security, supply checks, and a risk verdict for tokens on four named chains. It is clearly distinguishable from generic chain-read tools, though it does not explicitly contrast with the sibling token_dd__batch.

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 makes the use case apparent: due diligence on a token contract. It also notes a free preview and a $0.01 full report, but does not explicitly say when to use this versus token_dd__batch or other token-related siblings, nor does it state exclusions.

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

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

With no annotations, the description carries the full load and does well on the commercial/access side: it discloses the $0.01 per-call price in USDC on Base (eip155:8453), the x402 payment location params._meta['x402/payment'], and the HTTP GET endpoint. What it omits is failure behavior and idempotency (does a reverted simulation still cost $0.01?), plus whether this call itself is read-only.

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

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

The preflight purpose is front-loaded, but it is padded with boilerplate ('Base agent toolbox'), an HTTP URL, and a full segment about a different endpoint. Roughly half the text does not serve this tool's invocation.

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?

It usefully names the return fields (revert reason, gas, EIP-1559 fees in ETH and USD), which matters since there is no output schema, and it explains payment. But it leaves the central ambiguity unresolved: what the four /verify-scoped parameters do when passed to preflight, and what happens if the tx is not yet found.

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 parameter meanings are already documented in the schema and the description repeats rather than extends them. Worse, the schema itself is ambiguous — four params are tagged '/verify:' inside a tool named preflight, and the description does not clarify that they are inert or ignored when this tool is invoked.

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 core action is stated well: '/preflight simulates a tx (revert reason, gas, EIP-1559 fees in ETH and USD) before you sign.' But the description then spends half its length describing '/verify', which is a separate sibling tool (txpreflight__verify) and accounts for 4 of the 5 input parameters. An agent reading this cannot be certain whether this tool also performs verification.

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?

'Before you sign' gives a clear timing cue, which is useful. However, there is no routing guidance to the sibling txpreflight__verify for receipt-proof use, and no statement of when this tool is inappropriate (e.g. already-mined transactions).

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

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

With no annotations, the description carries the full burden and does disclose the material behaviors: a paid call at $0.01 USDC on Base, payment passed in params._meta['x402/payment'], and the HTTP endpoint. It does not say what happens when the transfer did not settle or when a required constraint (pay_to/pay_from/amount_usd) fails, which is the main omission.

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

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

Compact, but front-loaded with the vague 'Base agent toolbox' and then devotes roughly half the text to /preflight, which is outside this tool's scope. Payment and endpoint details earn their place; the preflight sentence does not.

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

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

There is no output schema, and the description does convey what comes back (settlement proof with confirmations, amount, sender, recipient) plus the payment mechanics. Missing only the negative/failure outcome, which for a verifier is a meaningful gap but not a fatal one.

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 explains asset, pay_to, pay_from and amount_usd. The description restates the same constraint concepts ('amount, sender, recipient') without adding format or matching semantics 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 outcome for /verify: 'reads a receipt and proves a USDC transfer settled: confirmations, amount, sender, recipient'. The first sentence mixes in /preflight ('simulates a tx... before you sign'), which is a different sibling tool, so the description carries two purposes rather than one.

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 implied usage ('before you sign' vs. reading a receipt) suggests when each applies, and the payment prerequisite ($0.01 per call via x402) is spelled out. But there is no explicit statement like 'call this after the transaction is confirmed, not before' and no named alternative such as chainread__verdict or txpreflight__preflight.

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