Ni Biashara Shelves — Africa FX, freight & compliance checks (x402)

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

With no annotations, the description must disclose side effects itself, and it does: 'Does not move money itself' is a key behavioral caveat, and listing the three returned URL kinds tells the agent what a successful call yields. It could add more about checkout expiration or authorization, but it already covers the most important non-obvious trait.

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

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

Three short sentences each carry load: action plus when-to-use, return values, and the non-payment caveat. The main purpose is front-loaded and there is 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 tool with 13 parameters, no annotations, and no output schema, the description is too thin on invocation details. It explains the return URLs but not what the optional fields mean, when they are required, or what errors or pitfalls exist, so an agent will often have to guess at how to fill the generic fields.

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 23%, so the description needed to compensate for the 10 opaque parameters (mc, dot, address, first_time, license_* , etc.). It only reinforces that sku is a SKU and does not explain the other 12 parameters or how they map to different shelf types.

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: 'Creates a Coinbase checkout for any SKU'. It also gives the tool an explicit identity as an escape hatch and says to use it when no job-named tool exists, separating it from buy_shelf_pass and the other shelf-specific siblings without being tautological.

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

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

'Use this when no job-named tool exists' is an explicit routing rule: it tells the agent both when to choose buy_shelf and, by implication, when not to. This is the clearest possible usage guidance for an escape-hatch 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?

Adds substantial behavior beyond the annotations: it is free to call, payment happens on the returned URL, redemption uses the X-SHELF-PASS header, settlement is $0.99 USDC on Base, and the return is an x402 GET flow (402 → PAYMENT-SIGNATURE → delivery). It resolves the apparent tension between the 'buy' name and readOnlyHint=true by stating the tool only returns a URL while payment occurs externally.

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 front-loaded with price and credit conversion first, then validity, redemption, payment, and return flow. Sentences are dense but each carries distinct operational facts. Slightly long, but little 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?

For a payment-flow tool with no output schema and no params, the description covers everything needed: cost, currency/chain, credit math, eligible shelves, redemption header, and the exact call sequence. It could optionally point to get_pass_balance for post-purchase verification, but nothing essential is missing.

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

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

The tool takes zero parameters, so the baseline is 4 and there is no parameter semantics for the description to add. No information is missing in this dimension.

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 (buy/redeem) and resource (a Shelf Pass of 110 prepaid credits) with concrete economic detail ($0.99 for $1.10 of calls). It clearly conveys the prepaid-credit model without opening the schema. It stops short of naming the per-call alternative sibling (buy_shelf), so sibling differentiation is implied rather than explicit.

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 well signposted: valid on shelves priced ≤ $0.25, and 'the point for agents that check every load or counterparty' tells the agent the high-volume scenario this suits. The constraint gives an implicit exclusion. No explicit 'use buy_shelf instead when X' routing is present, which keeps it below 5.

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

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

Annotations already cover safety (readOnly=true, destructive=false, openWorld=true), so the description rightly adds what they don't: the $0.1 USDC cost on Base, that the tool call itself is free, and the x402 402→PAYMENT-SIGNATURE→delivery flow. That is meaningful operational context beyond structured fields, though rate limits or failure modes are unaddressed.

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?

Short, front-loaded with purpose then usage then pricing/payment mechanics. Sentences are dense but each earns its place; the x402 flow sentence is somewhat compressed but functional.

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 purpose, audience, cost, and the payment/return mechanism (x402 URL to GET). What it omits is what the 'plain flags' actually contain, though it gestures at the result shape.

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

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

Only one parameter and schema coverage is 100%, so the schema already documents 'mc' fully. The description repeats 'MC/docket number' but adds no format, validation, or example 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+resource (broker authority check) scoped to FMCSA data by MC/docket number. The 'broker' vs sibling 'check_carrier_authority'/'check_carrier_basics' distinction is implied by the resource noun but never made explicit, so an agent must infer which sibling 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?

Gives a clear scenario: 'The check a carrier or factoring agent runs before accepting a load from an unknown broker.' That establishes when to use it. It stops short of naming a preferred alternative or an exclusion (e.g. when to use check_carrier_authority 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?

Annotations already cover readOnly/openWorld/non-destructive. The description adds valuable non-annotation context: live federal data, plain risk flags, the $0.1 USDC fee on Base, the x402 payment flow (402 → PAYMENT-SIGNATURE → delivery), and clarifies the tool itself is free while payment occurs downstream. That payment mechanics disclosure is genuinely useful, though retry/timeout behavior is not 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?

Front-loads purpose, then data fields, then the audience/use case, then pricing and payment flow. Dense but each sentence carries information. Slightly overloaded by the payment-flow sentence, which is layered but relevant.

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

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

For a read-only, no-output-schema lookup, the description covers purpose, returned data, trigger context, and the payment/consumption flow — the missing piece an agent would otherwise be confused about (that the tool returns a payable URL rather than the data itself). Complete for its complexity.

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 describes both mc and dot as alternative identifiers, so the schema carries this. The description adds no parameter detail beyond what the schema states. 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 (federal record lookup), a specific resource (US motor carrier via FMCSA), and enumerates the returned fields (legal name, operating status, authority, safety rating, fleet size, crash/inspection summary). It's clearly distinguishable from the nearest sibling check_broker_authority (broker vs carrier) and check_carrier_basics.

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 trigger context explicitly: 'the check a freight-broker or dispatch agent runs before tendering a load.' It doesn't say when not to use it or name check_carrier_basics/check_broker_authority as alternatives, but the use case is concrete.

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

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

Annotations already cover readOnly, non-destructive and openWorld, so the bar is lower, yet the description adds substantial behavioral context: cost ($0.1 USDC on Base), the two-step x402 payment flow (402 → PAYMENT-SIGNATURE → delivery), and the clarifying note that the tool call itself is free while payment happens on the returned URL.

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 definition is front-loaded with the resource and data source, then cost and return behavior. It is somewhat dense with parentheticals and em-dashes, but every sentence carries information and none 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?

With no output schema, the description compensates by explaining what the tool returns (an x402 URL to GET) and the payment handshake. Combined with a fully documented single parameter and covering annotations, an agent has enough to call it, though rate limits or invalid-DOT behavior are 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?

The single 'dot' parameter is fully documented in the schema (100% coverage), so the schema carries the meaning. The description adds no format or syntax detail beyond noting the BASIC context, 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 resource (carrier safety BASIC measures from FMCSA's SMS), names the underlying data source, and enumerates what is measured (unsafe driving, hours-of-service, vehicle maintenance) plus the intervention-threshold flags. It also distinguishes itself from sibling check_carrier_authority by positioning as 'the depth check behind' 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?

Gives clear when-to-use guidance ('run both before tendering') and explicitly pairs it with the related shallow check, so the agent knows the sequencing. It lacks an explicit when-not-to-use or failure-condition note, but the positive routing 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?

Goes well beyond the readOnly/openWorld/non-destructive annotations by disclosing that output is deterministic rules-engine results rather than an LLM guess, the exact cost ($0.25 USDC on Base), and the full x402 handshake (402 → PAYMENT-SIGNATURE → delivery). This is exactly the non-obvious operational context annotations cannot carry.

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 purpose in the first sentence and then layers justification, payment, and return mechanics with no filler. Slightly dense — the title restatement opening and the payment sentence compete for attention — but every sentence 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?

With no output schema, the description correctly compensates by explaining what is returned (the x402 URL to GET) and what the payload contains. It leaves minor gaps such as behavior on an unsupported license_line value or response format after payment, but an agent has enough 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%, so the schema already documents both parameters fully, including the license_line vocabulary and the 0-40 integer range. The description only echoes 'by license line and years licensed' without adding format or defaulting nuance, 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?

Names a specific check (CE & renewal compliance) on a specific resource (Texas insurance license, TDI rules) and enumerates the outputs — CE hours, classroom/ethics requirements, renewal fees — by license line and years licensed. An agent can distinguish it from sibling check_tx_realestate_ce purely on domain 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 clear context for invocation: it is a deterministic rules-engine lookup scoped by license line and years licensed, and it explicitly states that calling the tool is free and the $0.25 payment happens on the returned URL. It does not name when-not-to-use or an alternative sibling (e.g. when to prefer a general TDI lookup), so it stops short of full when/when-not 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?

Goes well beyond the readOnly/openWorld annotations: it discloses that output is a deterministic rules-engine result rather than an LLM guess, the price ($0.25 USDC on Base), and the exact x402 call flow (402 → PAYMENT-SIGNATURE → delivery). The crucial clarification that calling the tool itself is free while payment occurs on the returned URL removes real ambiguity.

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 determinism, price, and payment flow; every sentence is informative. Slight redundancy between the pricing sentence and 'Free to call this tool; payment happens on the URL', but it is short and scannable.

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 only two fully-documented params and no output schema, the description supplies what an agent needs to invoke it, including what is returned (the x402 URL to GET) and the payment mechanic. It could add a note about the payload returned after payment, but nothing critical is missing.

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

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

Schema description coverage is 100%, so the schema already documents license_type and first_time values, and the description's 'by license type' adds no syntax beyond it. Baseline 3 applies when the schema carries the parameter burden.

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

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

Names a specific verb+resource+scope: TREC continuing-education hours, renewal fees, and active-license requirements for Texas real-estate licensees, filtered by license type. It clearly distinguishes itself from the adjacent check_tx_insurance_ce sibling by domain (real estate vs insurance).

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 domain scope ('for Texas real-estate licensees, by license type') implies when to use it, but there is no explicit when-to-use/when-not statement and no named alternative. An agent must infer that check_tx_insurance_ce is the sibling for insurance lines rather than real estate.

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

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

Goes well past the annotations by disclosing the cost ($0.5 USDC on Base), the payment/auth model (Shelf Pass via pass_token or X-SHELF-PASS, only spent above the ≤$0.25 ceiling), and the exact failure mode (payment_required with the x402 v2 URL and header name). It even pre-empts a misread by stating the tool does not return a bare payment link in place of the rate. Annotation readOnlyHint=false is consistent with a call that spends credits.

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 what the tool returns, then cost, then auth behavior, then the payout/failure caveat. It is dense but each sentence carries information an agent needs (contents, scope, price, pass behavior, non-payment return), 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?

With no output schema, the description correctly carries the return-shape burden: rows with source and time, plus the payment_required branch with the x402 URL. Combined with the priced/pass mechanics, an agent has everything needed to invoke it correctly and interpret both success and failure responses.

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 pass_token thoroughly; the description nonetheless adds value by naming the header alternative X-SHELF-PASS and the ceiling condition under which the token is not spent. That is a modest but real addition over the structured field.

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

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

Names a specific verb (brief) and resource (Africa FX daily), then enumerates the exact contents: every Frankfurter official pair, both Bybit-derived street quotes (USD-NGN, USD-GHS), their spreads, and per-row source/time. This distinguishes it from the sibling get_fx_official and get_fx_parallel tools without the agent needing to open any schema.

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

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

"One call for a morning pricing check" gives a clear usage context, and the surface area implies it consolidates the official and parallel partial views. It does not, however, explicitly state when to prefer it over get_fx_official or get_fx_parallel, so the routing guidance is implied rather than explicit.

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

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

The readOnlyHint=false annotation is ambiguous on its own, but the description explains why: the call spends credits/charges $0.01 USDC and can return payment_required with an x402 URL. It also discloses that the rate is a central-bank blend rather than a single fixing, and that responses carry source, as_of, and fetched_at. This is rich behavioral context well beyond the annotations.

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

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

Front-loaded with the purpose, then progressively discloses source methodology and payment semantics. Dense but every sentence carries information; it is slightly long for a one-rate lookup.

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

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

Despite no output schema, the description specifies what the response contains (source, as_of, fetched_at) and what failure returns (payment_required with x402 URL/header). Payment prerequisites and eligibility ceiling are all covered, so nothing needed to call it correctly is missing.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real value by enumerating the eight valid currencies for `pair` and clarifying that pass_token is the in-band alternative to the X-SHELF-PASS header. It does not add pair-format syntax 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 verb (get/return), resource (official FX rate), and scope (one African pair vs USD) and names the source (Frankfurter) plus the eight supported currencies. An agent can distinguish it from get_fx_parallel and get_fx_africa_brief by the word 'official' and the single-pair 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?

It explains the gating conditions (pass_token / Shelf Pass ≤ $0.25 returns data, otherwise payment_required), which is useful context, but never explicitly says when to pick this over get_fx_parallel or get_fx_africa_brief. Usage is only implied by 'official'.

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 annotations only declaring safety hints, the description carries the behavioral load: it discloses the price ($0.05 USDC on Base), the payment-wall behavior (returns payment_required with x402 v2 URL and header name, not a bare payment link), and credit-spend semantics. This is unusually rich context beyond what the annotations supply.

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 purpose and methodology, then payment behavior. Mostly earns its place, though it repeats the title verbatim as its first sentence and includes a slightly defensive closing line ('does not return the rate as a bare payment link').

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 explains the two possible return paths (data vs payment_required) and the payment mechanics, which mitigates the missing output schema. For a 2-param, 100%-coverage read tool, 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 coverage is already 100%, so the baseline is 3. The description adds meaning to pass_token (valid on eligible shelves, returns data and spends credits, not spent above the ceiling) and reasserts the required pair, giving context beyond the schema's own field descriptions.

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 (street/parallel-market FX rate) with explicit scope (USD-NGN or USD-GHS) and defines the methodology (Bybit P2P median VWAP / USDT-USD basis + Frankfurter reference + spread). It also distinguishes itself from siblings by stating 'Not a central-bank rate' (vs get_fx_official) and noting OKX is archived.

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 conditions under which data is returned (valid Shelf Pass on a shelf ≤ $0.25) versus when payment_required is returned, and clarifies it is not a central-bank or bureau-de-change quote. It does not explicitly name get_fx_official/get_fx_africa_brief as the alternatives to use instead, so routing vs siblings 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 provided, the description carries the full burden. It discloses that delivery is included only after Coinbase reports payment COMPLETED, which is useful behavioral context. However, it doesn't mention any side effects, required permissions, or what happens if payment is not completed, leaving some gaps for a tool that likely involves a financial transaction.

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

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

The description is a single sentence that is efficient and front-loads the primary purpose. It includes a conditional detail that is relevant to the tool's behavior without unnecessary fluff. Slightly more structure could be added, but it's appropriately concise.

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, the description covers the core purpose and a key behavioral condition. However, it lacks details on what the returned status looks like, error handling, or any prerequisites (e.g., must have an active order). Given the simplicity, it's adequate but not fully complete.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions 'order_id' implicitly by referring to 'the order', but doesn't explain the format or any constraints beyond what the schema's type 'string' provides. The description adds minimal value for the single parameter, so a baseline 3 is appropriate given the low complexity.

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 ('Returns') and resource ('order status'), and adds a meaningful detail about when delivery is included. It distinguishes from siblings by focusing on order status rather than shelf operations, though it doesn't explicitly name alternatives.

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

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

The description implies usage for checking order status and collecting delivery after payment completion, but it doesn't explicitly state when to use this tool versus alternatives like buy_shelf or list_shelves. The context is clear enough for an agent to infer, but no exclusions or alternative routing 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions 'Free' (a cost attribute) and instructs to pass a token, but it does not state that the operation is read-only, has no side effects, or what happens on invalid tokens. The behavioral profile is largely undisclosed.

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

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

The description is very short but not well-structured. The standalone 'Free.' adds little value and the phrase '/shelf/shelf-pass-100' is cryptic. It is under-specified rather than efficiently concise, and the main purpose is not 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?

With no output schema and no annotations, the description should explain enough to invoke the tool correctly. It provides the token source but omits the return value, error behavior, and confirmation that the operation is safe. For a simple one-parameter tool this is still a notable gap, though the title partially covers the expected 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?

The schema already describes the token as a 'pass_… token' with 100% coverage, so the baseline is 3. The description adds the source of the token ('from buy_shelf_pass /shelf/shelf-pass-100'), which is helpful context. However, the endpoint path is cryptic and the instruction is terse, adding limited meaning 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 does not explicitly state that the tool checks a credit balance. It only says 'Free. Pass the token from buy_shelf_pass /shelf/shelf-pass-100.' This is an instruction, not a clear statement of the operation. The title provides the purpose, but the description itself fails to describe what the tool does.

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

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

The description gives a prerequisite (obtain token from buy_shelf_pass) but does not indicate when to use this tool versus its siblings. It does not mention alternative tools like check_broker_authority or check_carrier_authority, nor does it specify conditions or exclusions. The token-source hint is useful but not enough for selection decisions.

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?

There are no annotations, so the description carries the behavioral burden. It discloses that the tool is free to call, which is a useful cost-related behavior, and clarifies how the kind parameter changes the result set to include owner-fulfilled work. It does not mention auth, rate limits, or side effects, but the verb 'list' implies a read operation and the core behavioral traits are 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?

Two sentences contain the essential information with no filler. The primary purpose and default behavior are front-loaded, followed by the optional parameter guidance and the free-to-call note.

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 listing tool with no output schema and no annotations, the description is complete: it names the resource, what is returned, the optional parameter values and their effect, and the cost of calling. An agent can reasonably decide whether and how to invoke this tool without further clarification.

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

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

The schema already documents the kind parameter with an enum and a default of data, so the baseline is 3. The description adds meaning by explaining that service and all include owner-fulfilled work, which gives an agent a reason to choose one value over another beyond the raw enum.

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: it lists shelves sold by Ni Biashara, with the default being data shelves. It also names the return contents (price in USD, params, job-tool name, x402 URL), which clearly distinguishes it from purchase-focused siblings like buy_shelf.

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

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

The description gives clear context for when to use it: to list shelves, with data as the default and service/all available via the kind parameter. It does not explicitly name alternatives or state when not to use it, but the context is sufficient for this simple listing tool.

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

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

Annotations only cover the safety profile (readOnly, non-destructive, openWorld). The description goes well beyond them: the x402 payment flow (402 → PAYMENT-SIGNATURE → delivery), $0.25 USDC on Base, that the tool call is free and only the returned URL charges, and that output is machine-grade. These are exactly the traits an agent needs before paying.

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, with the cost and payment mechanics layered after the capability statement. Slightly redundant by restating the title verbatim as the opening sentence, 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?

No output schema exists, and the description compensates by explaining the return value and follow-up flow (the x402 URL to GET). Direction, size limit, cost, and alternative are all covered, leaving nothing an agent needs 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%, so both params (text, direction with en-sw/sw-en default) are already fully documented. The description restates the 120-word limit but adds no syntax or format detail beyond the schema. Baseline 3 applies when the schema carries the semantics.

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

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

States a specific verb+resource (English↔Swahili localization), the mechanism (instant machine pass, open translation model, in-process), and a hard constraint (up to 120 words). Explicitly distinguishes itself from the human-reviewed 500-word alternative, so an agent can tell the two apart 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?

Names the intended cases (UI strings, alt text, short product copy needed mid-run) and routes to the alternative for higher-quality needs ('for native-quality human-reviewed copy up to 500 words, buy swahili-localization-500w'). The when/when-not split is explicit and actionable.

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?

Beyond the readOnly/openWorld annotations, it discloses matching methodology (deterministic normalized-name and token matching), output semantics (CLEAR/REVIEW/HIT verdict, as_of and checked_at freshness), cost ($0.02 USDC on Base) and the full x402 payment handshake. That is exactly the behavioral context annotations cannot carry.

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 list scope before the mechanics, pricing and payment flow. It is dense and the pricing/x402 sentence could be tightened, but each clause carries operational value and nothing is redundant 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?

Despite having no output schema, the description specifies the return shape (verdict plus as_of/checked_at) and the delivery mechanism (x402 URL). An agent knows what it gets and how to pay, leaving no meaningful gap for a one-parameter 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?

With a single parameter at 100% schema description coverage, the schema already documents 'name' fully. The description confirms it screens 'a person or company name' but adds no format, normalization, or edge-case guidance beyond the schema baseline.

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

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

States a specific verb (screen) and resource (person/company name) against named lists (OFAC SDN + Consolidated), with scope quantified (~40k names + aliases). It is clearly distinguishable from the sibling screen_sanctions_wallet, which screens a different identifier type.

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 check a payments, marketplace or KYC agent runs on every new counterparty" gives concrete usage context and the trigger (new counterparty). It does not explicitly state exclusions or when to prefer a sibling like check_carrier_authority, but the context is clear enough to route 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?

Goes well beyond the readOnly/openWorld annotations: discloses deterministic exact-match semantics (CLEAR or HIT), the absence of clustering/risk scoring, a concrete cost ($0.01 USDC on Base), and the full x402 payment flow (402 → PAYMENT-SIGNATURE → delivery) including that the tool call itself is free. This is substantive operational context an agent cannot infer from structured fields.

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

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

Front-loads the core action, then stacks the distinguishing details efficiently. Dense but each clause carries information; the title repetition at the start is the only mild 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?

Despite no output schema, the description explains the return shape (CLEAR/HIT verdict plus the x402 URL to GET) and the payment handshake, so an agent knows both the outcome and next step. Nothing needed to invoke it correctly is missing.

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

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

Schema coverage is 100% and the single 'address' parameter is already documented as 'digital currency address to exact-match (required)'. The description's 'exact-match a blockchain address' reinforces rather than extends that, 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 precise verb+resource: exact-match a blockchain address against OFAC Digital Currency Address identifiers from the SDN XML. It explicitly distinguishes itself from the name-screen sibling by noting it's 'the same Treasury list we ingest for name screens', so an agent can route address vs. name screens correctly.

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?

Clear context for when to use it (blockchain address screening against OFAC) and what it is not (no chain intel, no clustering, no risk score). It references the sibling name-screen use case but never explicitly instructs 'use screen_sanctions_name for persons/entities', leaving that routing implicit.

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?

Beyond the annotations (readOnlyHint, openWorldHint, destructiveHint=false), it discloses the cost ($0.25 USDC on Base), that the tool call itself is free, the x402 payment handshake (402 → PAYMENT-SIGNATURE → delivery), the verdict scale (TENDER/HOLD/REJECT), the sourcing (FMCSA QCMobile, OFAC as_of), and the deliberate omission of any fraud score. This is substantial undisclosed-by-annotation context.

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 pack's contents and scoped tightly, though the first line largely restates the title and a few clauses (cost, payment flow) sit as a run-on. Still, nearly every sentence carries load-bearing 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, the description must explain returns, and it does: the verdict values and the x402 URL to GET. Combined with the payment mechanics and sourcing, an agent has everything needed to call and interpret it.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds conditional meaning: broker_mc triggers the broker-authority check, name triggers the OFAC screen, and dot/mc cover the carrier. It clarifies behavior the schema only lists.

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 composite action and enumerates exactly what it bundles: FMCSA authority, SMS BASICs, FMCSA broker authority, and an OFAC name screen. This makes it distinguishable from the narrower siblings (check_carrier_authority, check_broker_authority, check_carrier_basics, screen_sanctions_name) despite not naming them, since it states it is the all-in-one pack.

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 before you tender" gives a clear triggering context, and the description attaches each check to its parameter. It does not explicitly say when to prefer the individual check_* tools over this bundle, so it stops short of full alternative routing.

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