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

No annotations provided, so description carries full burden. It discloses pricing ($0.01 USDC on Base per call), payment flow (rail quotes via 402, server verifies exact scheme/network/token/payee), spend cap enforcement, and payer key security. Slight gap: doesn't explain what happens if quote exceeds caps or settlement 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 purpose and routing, then pricing/security details. Every sentence earns its place, though pricing details could be slightly condensed. Overall efficient and well-structured.

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

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

For a single optional param tool with no output schema and no annotations, the description covers purpose, alternatives, default behavior, pricing, verification, spend caps, and key security. Missing only edge-case failure behavior, which is minor for a read-like audio focus 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%, baseline 3. Description adds practical context: 'Optional length in minutes (1-120); omit for the rail default,' reinforcing omission behavior and default beyond schema description.

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: 'Focus audio lane — steady Brian Booms soundscapes for deep work and concentration.' Distinguishes clearly from siblings by naming steward_audio_rest (winding down) and steward_audio_match (mood track).

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?

Explicit when to use ('Choose this for working') and when to use alternatives ('choose steward_audio_rest for winding down, or steward_audio_match when you want a track picked for a specific mood').

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 delivers substantial behavioral context: cost ($0.01 USDC on Base), the 402 quote rail, quote verification criteria, spend-cap refusal, and payer-key locality. It omits failure/no-match behavior and does not explicitly state the operation is read-only, which an agent must otherwise infer.

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 sibling routing are front-loaded in the first two sentences; the payment paragraph is dense but each clause (price, rail, verification, caps, key safety) is load-bearing for a paid tool. Slightly long overall, 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?

Covers selection, cost, and payment mechanics thoroughly. With no output schema, the return is only sketched as "a matching track recommendation", so structure of the result is left undescribed, which is the one meaningful gap for a single-param discovery tool.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds example inputs ("a quiet rainy evening", "pre-workout energy") that widen the intended semantic range beyond the schema's single example and clarify that moments and occasions are valid, not just emotions.

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 ("Recommend") and resource ("Brian Booms track") plus the input dimension (emotion, moment, occasion), and explicitly contrasts itself with two named siblings. An agent can differentiate this from steward_audio_rest and steward_audio_focus without opening any schema.

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

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

Gives an explicit when-to-use condition ("use it when you don't know which track fits") and routes to alternatives with their own conditions ("ready-made listening lanes use steward_audio_rest (wind-down) or steward_audio_focus (deep work)"). Selection between the three tools is fully determined by 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?

No annotations are provided, so the description carries the full burden, and it does so well: it discloses the paid model ($0.01 USDC on Base), the 402 quote flow, verification criteria (scheme, network, token, payee), automatic settlement, spend-cap refusal behavior, and that the payer key stays local. It stops short of describing the return payload (e.g., what the audio lane actually returns) or error/repeat-call 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 purpose and routing guidance, then payment mechanics. It is a bit long, but every sentence covers material an agent needs given the absence of annotations and output schema.

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 optional-param audio tool with no output schema and no annotations, the description covers selection, parameter default, and the full payment/verification lifecycle. Only the return-value shape is left unspecified, a minor gap given output schema is absent.

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

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

The single parameter is already fully documented in the schema at 100% coverage (range 1-120, omission default). The description merely restates the same range and omit-default, adding no new semantics, so the baseline 3 applies.

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

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

States a specific verb+resource and scope: a 'wind-down audio lane' of calm soundscapes for rest and recovery. It explicitly names the siblings it is NOT for (steward_audio_focus for deep work, steward_audio_match for mood-picked tracks), so an agent can disambiguate without opening schemas.

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

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

Gives explicit when-to-use ('sleep and relaxation') plus the conditions that route to alternatives, naming both sibling tools. Nothing about tool selection 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, the description carries the behavioral burden and does so well: 'Free, read-only — never signs or spends' discloses the safety profile and that it is non-mutating, and 'never signs or spends' preempts a payment-flow misconception. It doesn't cover pagination or caching, but for a small static catalog that is minor.

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

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

Front-loaded with the purpose and scope, followed by next-step routing, sibling disambiguation, and the safety note in that priority order. Every clause earns its place with no filler.

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

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

No output schema exists, but the description names the returned fields, the result count, and the follow-on tools, so an agent has everything needed to call and chain it. Nothing material is missing for a zero-parameter read-only catalog 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 tool takes zero parameters, so the baseline is 4 and there is nothing for the description to clarify or compensate for. It also helpfully documents the return shape (sku, name, USD price) in place of a schema.

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

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

States a specific verb+resource ('List everything buyable from Brian Booms'), quantifies scope (29 products), and enumerates the catalog categories. It explicitly contrasts itself with the sibling steward_directory ('for the merchant directory (who sells)'), so an agent can distinguish the two without opening schemas.

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

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

Gives an explicit entry-point instruction ('Start any purchase flow here') plus the exact follow-up routing: steward_product for one item, steward_purchase_instructions for live payment terms. It also names when NOT to use this tool, directing merchant-directory lookups to steward_directory.

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 'live fee data', 'Advisory only: neutral ranking, no wallet, no custody, moves nothing', and 'Free, read-only', which is the key safety profile. It does not cover latency, caching, or fee-source freshness, so it falls just short of complete.

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

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

Three tight sentences, front-loaded with the core purpose, then the sibling routing note, then the safety caveat. No filler; each clause carries information.

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

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

No output schema exists, and the description compensates by stating the return shape ('the ranked list plus the single cheapest route'). Combined with the advisory/read-only framing, an agent has everything needed to call it correctly.

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

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

Schema description coverage is 100% (both amount_usd range and the token restriction are documented in the schema), so the baseline is 3. The description adds only the amount's USD framing and route scope, no syntax or semantics beyond the schema.

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

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

States a specific verb+resource (cheapest of 6 crypto transfer routes for a USD amount) and enumerates the exact route set, so the agent knows precisely what is compared. It is clearly distinguishable from steward_route_fees, which it names.

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

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

Explicitly instructs: 'Use this for a quick answer; use steward_route_fees for the full fee table.' This gives both the when-to-use condition and the named alternative, leaving nothing 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 burden of behavioral disclosure. It clearly states the tool is free, read-only, and never signs or spends, which directly addresses the most critical safety concern. However, it does not mention authentication requirements, rate limits, or pagination behavior, leaving some gaps.

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

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

The description is tightly written and front-loaded: it begins with what the directory is, then its ranking policy, then the sibling distinction, then return format and safety notes. Every sentence earns its place with no redundancy.

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

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

Given a zero-parameter, read-only listing with no output schema, the description provides all necessary context: what it returns, its scope, the alternative sibling tool, and its safety profile. Nothing an agent needs to call it correctly is missing.

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

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

The tool takes zero parameters, so the baseline is 4 per the scoring rules. The description does not need to explain parameter meanings and appropriately does not include any.

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

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

States a specific resource (the Steward Standard merchant directory) and scope (57 x402 merchants ranked by public merit score), and explicitly distinguishes itself from the sibling steward_catalog ('for WHAT Brian Booms sells use steward_catalog'). An agent can immediately tell what this tool returns and how it differs from the product catalog.

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

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

Explicitly describes when to use this tool versus the alternative: it lists WHO sells (merchants) while steward_catalog lists WHAT is sold. Also notes it returns the full machine-readable directory and is free/read-only, giving clear context for invocation.

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 so thoroughly: it discloses the cost ($0.01 USDC on Base), the 402 quote flow, what the server verifies (exact scheme, Base network, USDC, Steward payee), that it refuses quotes exceeding per-call or daily caps, and the privacy guarantee that the payer key never leaves the machine. It also states the output content (lucky number 1-99 plus a calm word) and that no third-party upstream is involved.

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 core purpose and the sibling routing are front-loaded in the first two sentences, and every subsequent sentence carries distinct load (session behavior, payment mechanics, privacy). The payment clause is dense and verges on long-winded, but 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 single-optional-param, no-output-schema tool, the description covers purpose, output shape, session semantics, cost, payment verification, spend caps, and key custody. An agent has everything needed to decide to call it and to anticipate the paid-call flow.

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

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

Schema description coverage is 100% for the single optional 'session' parameter, so the schema already documents its semantics. The description's line 'Pass a session id to avoid repeats within a session' restates the same behavior rather than adding syntax or format detail beyond it, which is the baseline-3 case when the schema does the heavy lifting.

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

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

States a specific verb and resource ('One warm, original fortune — a lucky number (1-99) plus a calm word'), and explicitly distinguishes itself from the nearest sibling by name ('Fortunes, not jokes: for humor use steward_joke instead'). An agent can select this over steward_joke without opening either schema.

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

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

Names the alternative tool and the condition that selects it ('for humor use steward_joke instead'), and states the session-id usage pattern for avoiding repeats. Nothing about when to reach for this tool versus a sibling 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, the description carries the full burden and does so: it discloses the price ($0.01 USDC on Base per call), the 402 quote-and-settle flow, the exact verification criteria (scheme, network, token, payee), spend-cap enforcement, and the security property that the payer key never leaves the machine. This is far beyond a bare 'convert currency' statement.

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

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

Front-loaded with purpose, then routing guidance, then payment mechanics — a sensible order. The payment sentence is dense but every clause (cost, rail, verification, caps, key safety) earns its place; only minor tightening is possible.

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, routing, and scoping are covered thoroughly. With no output schema, the description leaves the return shape (converted amount, applied rate, timestamp) unspecified, which is the one remaining gap for a conversion 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 schema already documents amount, from, and to with format, case handling, and positivity constraints. The description adds no parameter-level detail beyond that, which is the expected baseline when the schema does the heavy lifting.

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

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

States a specific verb and resource ('Fiat currency conversion at current reference rates') plus concrete use cases (pricing, payouts, multi-currency accounting). It also explicitly distinguishes itself from the sibling steward_cheapest_route, so an agent can route without opening any schema.

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

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

Gives both a when-to-use ('pricing, payouts, or multi-currency accounting'), a when-not ('Reference rates only, not execution quotes'), and the named alternative for the excluded case ('for crypto transfer fees use steward_cheapest_route instead'). Nothing is left to inference.

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

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

With no annotations, the description carries the full behavioral burden and does so well for the payment rail: cost ($0.01 USDC on Base), the 402 quote flow, quote verification criteria (scheme, network, token, payee), spend-cap refusal, and key custody. It omits data freshness, caching, and rate-limit behavior beyond spend caps, which keeps 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?

Purpose is front-loaded, followed by the sibling distinction, then the payment mechanics. The final payment sentence is long and dense but every clause carries distinct information an agent needs (cost, verification, caps, custody).

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, but the description implies the return is flyover times, and it fully covers the payment/auth prerequisites for a paid call. For a 2-required-param read tool this is close to complete; only return-shape detail is 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 description coverage is 100% – both lat and lon are fully documented in the schema with ranges and examples. The description adds only the word 'location', so baseline 3 is appropriate.

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

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

States a specific verb and resource ('Upcoming visible ISS flyover times for a location') and names the data source (CelesTrak). It explicitly distinguishes itself from the closest sibling, steward_weather, so an agent can route without opening either schema.

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

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

Gives concrete use cases ('skywatching or satellite-aware scheduling') and an explicit when-to-use-vs-alternative rule: 'weather for conditions, this for flyovers.' Nothing is left to inference.

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

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

With zero annotations, the description carries the full burden and does so thoroughly: it discloses the cost ($0.01 USDC on Base), the 402 quoting/verification flow, exact scheme/network/payee checks, automatic settlement, spend-cap refusal behavior, and the guarantee that the payer key stays local. This is a rich, safety-relevant behavioral profile 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?

The purpose is front-loaded ahead of the payment details, and every sentence is relevant for a paid tool. The payment clause is a long run-on, but its content (cost, network, caps) earns the space rather than padding.

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

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

For a single-optional-param tool with no output schema and no annotations, the description covers purpose, parameter behavior, and the full payment lifecycle an agent needs to invoke it correctly. Only the routing against sibling content tools is absent.

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

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

Schema description coverage is 100% and the schema already explains the session id's repeat-avoidance semantics, which the description essentially restates. The only marginal addition is framing omission as a 'one-off' use case, which does not meaningfully exceed the schema.

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

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

States a specific verb+resource ('One clean, original, family-friendly joke') and the source ('Synthetic Universe'), so an agent immediately knows this returns a joke. It does not, however, distinguish itself from adjacent content siblings like steward_fortune or steward_sleep_tip, leaving the choice to inference.

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

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

Gives clear guidance on the optional parameter ('pass a session id to avoid repeats; omit it for a one-off joke'), which is genuinely useful context. But it never says when to pick this tool over sibling content tools (fortune, sleep_tip, wiki), so usage is only implied.

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 does well: 'Free, read-only — never signs or spends' rules out cost and custody side effects, and the byte-exact/prevention framing signals it is a static reference rather than an action. It stops short of describing the response shape, but for a no-side-effect guide the safety profile is 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?

Three tight clauses, front-loaded with the deliverable, then the trigger condition, then the safety guarantee. No filler and nothing repeated from structured fields.

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 zero-parameter reference tool with no output schema, the description gives enough: what it returns (a byte-exact header guide), when to invoke it, and its non-destructive nature. Only a hint about the returned artifact's format would improve it further.

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, so the baseline is 4 and there is nothing for the description to clarify. The absence of any argument-format caveat is appropriate here, since none exist.

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 deliverable (a byte-exact guide for constructing an X-PAYMENT header) with precise scope (x402 v1, EVM, USDC on Base). It is unmistakably distinct from steward_purchase_instructions and every other sibling, which are all operational rather than reference tools.

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

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

Explicitly says when to call it ('BEFORE an agent's first self-paid purchase via steward_purchase_instructions') and names the sibling that triggers the need. It even supplies the motivation — most failed payments are header-format errors — so the agent knows the cost of skipping 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, but the description states 'Free, read-only — never signs or spends', covering the safety profile. Adds the price field and delivery method context. Minor gap: no return-shape or error behavior beyond field list.

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

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

Three compact sentences: purpose, sequence guidance, safety note — front-loaded with zero 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?

Complete enough for an agent: purpose, sequencing, and safety are covered. No output schema, so field enumeration is helpful. A 4 rather than 5 because return format details (e.g., error on unknown sku) are undefined.

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

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

Schema coverage is 100%, so baseline is 3. The description reinforces the sku requirement via 'after steward_catalog to zoom in on a single sku', tying the parameter to its source, which is modest added value.

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 ('Full details for one catalog product') and enumerates the fields returned, distinguishing it from steward_catalog (zoom in on a single sku). An agent can select it without opening the schema.

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

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

Explicitly routes: use after steward_catalog to zoom in; when ready to pay, call steward_purchase_instructions. Names the alternative and the transition condition.

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

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

With no annotations, the description carries the full burden and does well: it discloses that the call is free and read-only, that it reads the 402 response but never pays it, and that data is parsed live. It stops short of covering error cases, rate limits, or what the agent must have configured wallet-side.

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 verb+resource before any caveats, and every clause provides actionable information. The dash-delimited clause and final sentence make it slightly denser than ideal, but nothing 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?

There is no output schema, but the description compensates by listing the fields returned, and it covers the prerequisite and the two payment paths. An agent has everything it needs to invoke this correctly.

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

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

Schema coverage is 100% and the single sku parameter is already documented as 'exactly as returned by steward_catalog'. The description reinforces the same constraint but adds no syntax, format, or edge-case detail beyond the schema, so the baseline 3 applies.

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

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

States a specific resource and enumerates the exact outputs (pay-to address, amount, asset, network, facilitator), so the agent knows precisely what it gets back. It distinguishes itself from steward_catalog by being the payment-requirements step rather than the discovery step.

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

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

Gives an explicit prerequisite ('Find the sku with steward_catalog first'), explains the payment flow ('agent pays with its own x402/EVM wallet'), and names the alternative path where no manual payment step is needed when using the server's paid tools.

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

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

With no annotations provided, the description carries the full burden and mostly does: it declares the tool free, read-only, and 'never signs or spends', and establishes data authority ('source of truth for settled spend'). It does not disclose return shape, pagination, or result limits, which matters since there is no output schema.

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

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

Front-loaded with what the tool returns, then usage, then the sibling distinction, then safety. Four sentences, all substantive; the only mild redundancy is restating 'in the open' and 'source of truth' twice toward the same point.

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

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

For a low-complexity single-param read tool, the description covers purpose, authority, alternative, and safety profile. The remaining gap is the response contents (what a receipt entry looks like), which matters more here because no output schema exists.

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

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

Schema coverage is 100% and the single 'wallet' parameter is fully documented with pattern and example, so the schema does the heavy lifting. The description only restates that any EVM wallet can be looked up and adds no format or edge-case detail beyond it — 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?

States a specific verb and resource ('look up any EVM wallet and see every cent it paid') for a named artifact (per-wallet receipts for settled Steward calls). It explicitly differentiates itself from the closest sibling by naming steward_spend_today as the local meter, so an agent can route without opening schemas.

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

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

Gives an explicit condition ('Use this to verify a payment actually settled') and an explicit alternative with its distinguishing trait ('for this server's own local meter see steward_spend_today'). When-to-use and when-to-use-something-else are both 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 the safety profile ('Free, read-only — never signs or spends'), plus the scope of knowledge covered. It stops short of describing the shape of the returned content, but for a zero-parameter, no-side-effect lookup the disclosed traits are the ones that matter.

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, front-loaded with what the tool covers and immediately followed by the routing instruction. Every clause earns its place: subject matter, when to read it, and the read-only guarantee.

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

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

For a parameterless knowledge tool with no output schema and no annotations, the description adequately covers what information it yields and its safety characteristics. It does not describe the return format, but with no output schema declared that gap is minor.

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

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

The tool takes no parameters, so there is nothing for the description to clarify; the baseline of 4 applies. No input semantics are needed or missing.

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 — the Booms Rewards program — and enumerates its contents (buyer earn rates, referral rates, free store enrollment). It is clearly a knowledge/documentation lookup rather than an action, which distinguishes it from action siblings like steward_iss_pass or steward_purchase_instructions, though the verb is implicit ('how X works' rather than 'get X').

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

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

It gives explicit triggering conditions and names the sibling it pairs with: read before buying via steward_purchase_instructions, or before enrolling a store as a merchant. An agent knows exactly when this tool is relevant without inferring anything.

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 supplied, so the description carries the full burden, and it does so well: it discloses the operation is free, read-only, advisory, holds no wallet/custody and 'moves nothing,' and that the ranking is neutral. It also flags that fee_source is 'live or typical' verbatim from the API. It stops short of covering error behavior, rate limits, or result freshness beyond the live/typical distinction.

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 before the disambiguation and safety notes. Every clause earns its place — route list, output fields, sibling routing, and advisory posture all carry 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?

With no output schema present, the description usefully names the return fields (fee_usd, total_usd, fee_source) and their provenance. Combined with explicit sibling routing and safety posture, an agent has everything needed to call it correctly.

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

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

Schema coverage is 100%, so both parameters (token, amount_usd) are already fully documented with ranges and formats in the schema. The description adds only the framing 'for a USD amount' and implies the token restriction, which does not meaningfully extend the schema. Baseline 3 is appropriate.

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

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

States a specific verb+resource ('Full ranked fee table for all 6 crypto transfer routes') and enumerates the exact routes and tokens covered. It explicitly distinguishes itself from the sibling steward_cheapest_route, so an agent can pick between them without opening either schema.

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

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

Gives an explicit when-to-use and when-not-to-use: 'Use this for the complete comparison; use steward_cheapest_route when you only need the winner.' The alternative is named and the selecting condition is stated, leaving nothing 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, the description carries the full burden and does so well: it discloses the price ($0.01 USDC on Base), the 402 quote flow, that the server verifies scheme/network/token/payee, that it settles from the wallet automatically, that it refuses quotes exceeding per-call or daily caps, and that the payer key stays local. This is rich behavioral and safety context beyond any structured field.

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

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

Front-loaded with purpose, then index behavior, then payment details — a sensible ordering. The payment paragraph is long but earns its place given the absence of annotations and the tool's paid nature; no sentence is pure filler.

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

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

For a single-optional-param tool with no output schema and no annotations, the description covers purpose, parameter behavior, payment mechanics, and spend-cap safety. Return shape is not described, but the tool is trivially simple, so this is nearly complete.

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

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

Schema description coverage is 100% and the schema already documents the index with the same omit-for-today wording and 0-11 bounds, so the description's restatement adds little. Baseline 3 is appropriate when the schema fully documents the single parameter.

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: it returns 'One genuine sleep-hygiene tip from Brian Booms' rotating collection of 12,' with a scoping note ('never medical claims'). It is clearly distinguishable from content siblings like steward_joke or steward_fortune by resource, though it does not name them explicitly.

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 explains the index mechanic (omit for today's rotating tip, pass 0-11 for a specific one), which is a usage instruction, but offers no guidance on when to prefer this over other steward_* content tools or any exclusions. Usage is implied by the resource name 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 delivers: it discloses in-memory, per-process lifetime, reset-on-restart behavior, that it is a safety rail rather than accounting, and that it incurs no rail call. These are exactly the traits an agent needs to interpret the value correctly.

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

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

Two sentences, zero filler, and the identity of the tool is front-loaded before the ephemerality caveats. Every clause adds decision-relevant 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-arg, no-output-schema read, the description covers what the value means, its lifetime, and its relationship to the authoritative sibling. The only gap is not stating the literal return shape, which is minor given the meter framing.

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?

Zero parameters, so there is nothing to document; the baseline of 4 applies. The description correctly spends none of its length on parameter details.

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

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

The description states a precise resource and scope: 'USDC spent through this process today', and explicitly contrasts itself with the sibling steward_receipts. The verb is implicit rather than stated ('get/read'), but no agent could mistake what this tool 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?

It gives clear operative conditions: 'Free, no rail call', and it routes the agent to steward_receipts as the source of truth for settled spend. It does not spell out an explicit when-to-use trigger, but the cost/scope caveats imply the correct context for calling 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?

With no annotations, the description carries the full burden and does so well: it discloses that the value is computed on the rail with no third-party dependency, the exact price and chain ($0.01 USDC on Base), the 402 quote-verification flow (scheme, network, USDC, Steward payee), automatic wallet settlement, spend-cap refusal, and that the payer key never leaves the machine. That is unusually rich behavioral disclosure 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?

Purpose and usage are front-loaded in the first sentence, followed by payment mechanics. The payment detail is long but largely earns its place for a paid tool; a little tightening of the quote-verification clause would help, keeping it just short of a 5.

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

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

For a single-parameter, no-output-schema tool, the description covers purpose, use contexts, and — critically for a paid call — the full payment and safety model. Nothing an agent needs to invoke it correctly is missing.

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

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

Schema description coverage is 100% — the tz parameter is fully documented in the schema with IANA examples (America/Chicago, Europe/London, Asia/Tokyo). The description adds no syntax or format detail beyond that, so the baseline 3 applies.

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

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

States a specific verb and resource — 'Current local time in any IANA time zone' — with a clear scope (any IANA zone). The sibling tools are all distinct resources (weather, fx, wiki, audio, etc.), so no confusion arises; an agent knows exactly what this 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?

Gives concrete use contexts — 'scheduling, reminders, or market-window checks' — which helps an agent recognize when to reach for it. However, it names no alternatives and gives no when-not guidance, so it falls 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 full behavioral burden and does so well: 'Free, read-only — never signs or spends' gives the safety profile, and it discloses exactly what the returned key verifies and how the signature is computed (sorted keys, no whitespace, UTF-8, signing_pubkey blanked). It omits any indication of caching/rate limits or the concrete response shape, 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?

Front-loads the resource, then packs the verification recipe and companion tool into a few tight clauses with no filler. The canonicalization detail is dense but earns its place for an offline-verification 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 no-param, no-output-schema tool, the description gives enough: what the key is, what it verifies, the canonical format needed to use it, and the sibling to pair with. Only the exact return encoding beyond 'hex' is left implicit, which is minor.

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

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

The tool takes zero parameters, so there is nothing to document and the baseline is 4. Schema description coverage is trivially 100% and the description correctly adds no per-parameter noise.

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?

Starts with a specific verb+resource: it returns the Steward Verified issuer's Ed25519 public key in hex. It also draws an explicit boundary with the sibling trust_verify_status ('reports the status this key lets you verify yourself'), so an agent can tell the two apart without opening either schema.

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

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

States the condition of use ('independently verify any Steward Verified record's signature offline') and names the companion/alternative tool (trust_verify_status). It stops short of an explicit when-not or a decision rule for choosing between the two, but the context is clear.

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

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

With no annotations, the description carries the full burden and does it well: it discloses cost ($0.01 USDC on Base per call), the 402 quote flow, what the server verifies (scheme, network, payee), spend-cap enforcement, and that the payer key stays local. It omits failure/retry behavior and forecast units, which is why it falls 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?

Purpose and the sibling disambiguation are front-loaded in the first sentence, followed by the payment mechanics. The payment paragraph is longer than typical but is load-bearing given zero annotation coverage; it is dense rather than 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 no-annotation, no-output-schema tool the description covers what an agent needs to invoke it: purpose, inputs, routing, and the full payment/authorization path. The remaining gap is what the forecast actually returns (units, fields) and error/edge behavior, which would matter more since no output schema exists.

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

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

Schema description coverage is 100%, so both lat and lon already carry ranges and worked examples from the schema. The description only adds 'any latitude/longitude', which conveys no syntax or format information beyond the structured fields — the baseline 3 for fully documented schemas.

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

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

States a specific verb+resource (current conditions plus 7-day forecast) and the exact input domain (any latitude/longitude). It explicitly names the sibling it is not (steward_iss_pass) and even notes they share coordinates, so an agent can route without opening either schema.

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

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

Provides use cases (trip planning, event scheduling, location-aware task prep) and an explicit alternative rule: 'Use this for weather; use steward_iss_pass for satellite flyovers at the same coordinates.' The when-to-use and the competing-tool condition are both stated outright.

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 the paid nature ($0.01 USDC on Base per call), the 402 quote flow, verification checks (scheme, network, token, payee), spend-cap refusal behavior, and the security guarantee that the payer key never leaves the machine. It stops short of stating the return format or confirming the operation is non-destructive.

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 purpose before payment details, and most sentences earn their place given this is a paid tool. The payment paragraph is dense but relevant; the product-vs-catalog aside is slightly tangential yet functional as disambiguation.

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 tool with no output schema and no annotations, the description covers purpose, parameter handling, cost, and payment mechanics thoroughly. The main remaining gap is that it never sketches the shape of the returned summary.

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 'topic' parameter, so the baseline is 3. The description adds value beyond the schema by instructing 'Pass the article title as-is; the rail resolves it,' clarifying that no normalization or disambiguation is expected from the caller.

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 — 'Concise summary of a Wikipedia article' — and frames the scope ('quick research context for agents'). It also explicitly distinguishes itself from one sibling (steward_catalog for buying Brian Booms products), so an agent can route correctly without opening the schema.

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

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

Gives a clear context ('quick research context for agents') and names a specific alternative with its own domain (steward_catalog for product purchases). It does not cover when-not-to-use relative to the other research-adjacent siblings, but the primary routing guidance is present.

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

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

With no annotations, the description carries the full burden and does so: it discloses read-only/advisory semantics, an explicit non-guarantee caveat, the price ($0.02 USDC on Base), the 402 quote flow, the exact validation criteria the server enforces (scheme, network, USDC, Steward payee), automatic settlement, spend-cap refusal behavior, and that the payer key stays local. This is far beyond what a name or schema conveys.

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 sibling routing are front-loaded, which is the right ordering for a selection decision. The payment-mechanics sentence is long, but every clause (quote validation, caps, key custody) is material given the absence of annotations, so it earns its space despite the density.

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 sketches return content well by naming the two signal classes (verification status, on-rail payment history). What is thinner is the shape of a returned attestation (fields, confidence, staleness), which an agent would have to discover empirically. For a 2-param read tool with full schema coverage, this is nearly complete.

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

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

Schema description coverage is 100%, so both `agent` and `operator_domain` are already documented with formats and length bounds. The description restates the identifier concept ('given wallet or identifier') but adds no syntax or cross-check detail beyond the schema. 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?

States a specific resource ('attestation signals for an agent') and enumerates the signal types: operator verification status plus observed on-rail payment history. It explicitly names the siblings it is not (trust_verify_status for domains, trust_screen for pre-payment), so an agent can route without opening any schema.

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

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

Gives explicit routing conditions: 'For domains use trust_verify_status; for a pre-payment decision use trust_screen.' It also frames the tool's role as advisory/read-only signals rather than a decision, which further scopes when to reach for it. Nothing is left to inference.

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

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

With no annotations, the description carries the full burden and discharges it: it declares the deterministic output, the advisory-only disclaimer, the fail-open-to-review failure mode, the exact cost and rail ($0.02 USDC on Base, 402 quote), quote verification criteria, spend-cap refusal behavior, and that the payer key stays local. This is unusually rich behavioral disclosure for a paid mutation-adjacent 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 purpose and output contract, then failure semantics, then routing, then payment mechanics. Dense but nearly every clause earns its place; the payment paragraph is long yet actionable for a paid tool, with only minor compression possible.

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 tool with no annotations and no output schema, the description covers the return contract (approve/review/decline), the failure behavior, the paid-rail prerequisites, and the sibling for deeper detail. Nothing an agent needs to invoke it correctly appears to be missing.

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

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

Schema description coverage is 100%, so the schema already documents agent, amount_usdc, and merchant_domain. The description restates the two required inputs ('an agent and a candidate USDC amount') but adds no syntax, format, or edge-case meaning beyond the schema, so the baseline 3 applies.

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

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

States a specific verb (screen) and resource (pre-payment counterparty), names the exact output set (deterministic approve/review/decline), and distinguishes itself from the sibling trust_agent_attestation by framing itself as the summary screen. An agent can tell it apart from trust_verify_status and trust_agent_attestation without opening a schema.

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

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

Clearly scopes usage to pre-payment screening and routes to trust_agent_attestation when full signal detail is needed, which is a genuine alternative-selection rule. It stops short of explicit when-not conditions (e.g. non-payment use cases), so it falls just short of the top band.

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: it declares read-only/advisory behavior, states that verification is never issued or purchasable here, and discloses the payment mechanics end-to-end ($0.01 USDC on Base, 402 quote, exact scheme/network/token/payee validation, per-call and daily spend caps, automatic wallet settlement, payer key never leaves the machine).

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 purpose and routing before the lengthy payment paragraph. Every sentence is substantive, though the payment/settlement passage is dense enough that it could be tightened slightly without losing meaning.

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 names the four returned fields, so return semantics are covered. Combined with the safety, cost and routing disclosure, nothing an agent needs to invoke this correctly is missing.

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

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

Schema description coverage is 100% and there is a single parameter, so the schema already documents format, length bounds and auto-lowercasing. The description references the domain concept but adds no syntax or format detail beyond the schema, so the baseline of 3 applies.

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

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

States a specific verb and resource ('Check whether a domain is Steward Verified') and enumerates the returned fields (status, method, issuance/expiry, endpoint count). It also explicitly distinguishes itself from two siblings by name, so an agent can route without opening any schema.

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

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

Gives explicit when-to-use ('before trusting a merchant domain') and names the correct alternatives with their selecting conditions: trust_agent_attestation for agent counterparties, trust_screen for pay/no-pay decisions. This is exactly the routing guidance an agent needs.

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