IoMarkets.tech ISO 20022 Test Bench

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

With readOnlyHint and openWorldHint=false already in annotations, the description adds real value by enumerating the four verdicts and explicitly stating that 'unknown' says nothing either way — a crucial interpretation caveat that prevents an agent from treating absence as evidence of fraud. It does not mention data freshness or map coverage limits, which would complete the picture.

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

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

One sentence poses the core question, the second delivers the verdict taxonomy with parenthetical definitions. The purpose is front-loaded and no sentence is redundant.

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

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

No output schema exists, and the description compensates by fully specifying the return vocabulary and the semantics of each value, including the negative-inference trap for 'unknown'. For a read-only lookup tool this leaves nothing an agent needs in order to call it and interpret the answer.

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 earns a bump by explaining how chain and address combine into the 'other-chain' verdict and implicitly why symbol matters (catching a listed symbol on a different contract). It still does not state whether symbol is required for impostor detection or what happens when it is omitted.

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

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

States a specific verb (check) and a specific resource (token contract against the Tokenized Asset Map), then sharpens it to a concrete question about issuer provenance on a chain. This clearly separates it from sibling lookups like get_tokenized_asset or list_tokenized_assets, which return asset data rather than a verdict.

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 framing ('is it the issuer's own contract for a tokenized fund or security on that chain?') makes the use case explicit and reads as a pre-trade/pre-interaction verification step. It gives no explicit when-not-to-use or names verify_asset_with_issuer as the alternative, so routing between the two verification tools 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?

Annotations already declare readOnlyHint=true and openWorldHint=false. The description adds meaningful behavioral context: pricing is based on per-call x402 rates, comparisons are against indicative subscription plans, and omitted routes count as zero. It does not describe the return format, but the safety profile is covered by annotations.

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

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

Two sentences, front-loaded with the purpose and followed by a precise input rule. Every sentence earns its place.

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

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

For a read-only estimation tool with full parameter documentation and no output schema, the description gives enough context to call it correctly. It could say more about the response shape, but the core behavior and input semantics are clear.

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

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

Schema coverage is 100%, so all five route parameters are fully documented in the schema. The description adds an important semantic rule not present in the schema: routes not supplied are treated as zero, which clarifies default behavior.

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

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

The description clearly states that the tool estimates monthly Data API spend at per-call x402 prices and compares it against subscription plans. It identifies the resource and calculation, though it does not explicitly differentiate from sibling verification or listing 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?

Usage is implied by the input instruction to provide monthly call volumes per route. There is no explicit guidance on when to use this tool versus alternatives, nor any exclusions or prerequisites.

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 readOnlyHint, the description explicitly says the tool calls nothing, pays nothing, and reads from the API's code. It also discloses uncharged error responses (400 and 422), which is important behavioral context for a paid audit endpoint.

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

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

The description is front-loaded with the endpoint and purpose, then packs body, limits, price, responses, and usage into a single dense but purposeful passage. Every clause contributes useful information without filler.

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

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

For a read-only documentation tool with one optional parameter and no output schema, the description covers what is returned, error behavior, limits, pricing, and how to use the validation path. An agent has enough context to invoke it correctly.

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

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

Although schema coverage is already 100%, the description adds substantial meaning to the optional body parameter by listing allowed pairs, fill fields (ts, fill_price, qty, side), limits, and validation use. This goes well beyond the schema's brief body 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?

The description states a specific documentation purpose: explaining exactly how to call the execution-audit endpoint, including body format, limits, price, and responses. It also distinguishes itself from an actual audit call by saying it calls nothing and pays nothing.

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 clearly tells the agent to use a draft body to check validation first before paying, which is strong usage guidance. It does not explicitly name alternatives such as verify_execution_report, so it falls just short of fully explicit when/when-not/alternative guidance.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered by structured data. The description still adds real behavioral context beyond that: the tool has two modes (single-code lookup vs. full enumeration) and the input codes originate from reports, which tells the agent how to source its argument.

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

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

Two short sentences, each carrying distinct information — capability plus fallback mode — with the primary purpose front-loaded. No filler or restatement of the title.

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-parameter lookup tool with no output schema, this covers both invocation paths and the data source of the argument. What is missing is a hint about the shape of the answer (does it return only a definition, or also remediation steps and examples?), which matters given the description promises 'how to fix 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 goes past the schema by explaining the consequence of omitting the code (behavior changes to listing every code) rather than merely restating that 'code' is a string from a report. It does not cover case sensitivity or whether unknown codes error or return nothing, which would have justified a 5.

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 (explain a Test Bench issue code) and disambiguates further with three concrete code examples, which ties it to the domain of report issue codes rather than general terms. The second sentence adds a distinct second mode (list all codes when no code is given), so an agent knows exactly what it gets back in either case.

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 'without a code' clause implicitly documents the optional-parameter path, and the schema notes the code comes from a report, so the intended entry point is inferrable. However, no sibling is named as an alternative or exclusion — notably explain_term and explain_execution_request, which are adjacent 'explain' tools — leaving the agent to guess the boundary.

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

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

Annotations already establish a safe, closed-world read (readOnlyHint=true, openWorldHint=false). The description adds a genuine behavioral trait beyond that: the parameterless mode enumerates the available vocabulary, which an agent cannot derive from the schema or annotations.

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

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

Two sentences, no filler, and the core capability is front-loaded before the example parenthetical and the fallback mode. The example lists are dense but every item is load-bearing because they define the breadth of acceptable input.

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-optional-parameter lookup with no output schema, the description covers everything needed: what it returns ('a plain-English meaning'), the full vocabulary scope, and the no-argument behavior. Nothing an agent needs in order 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 baseline would be 3, and the description earns an extra point by characterizing the accepted value space in a way the schema's bare 'The word or tag to explain' does not — acronyms (IBAN, LEI, UETR), site concepts (x402, MCP), and XML tag abbreviations such as GrpHdr or IntrBkSttlmAmt.

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 (plain-English meanings of site vocabulary and ISO 20022 tag abbreviations) and enumerates concrete example terms, so an agent immediately knows what domain this glossary covers. It stops short of differentiating itself from near-neighbors like explain_issue or get_guide, leaving the agent to infer the boundary.

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 one useful call-mode rule — 'Without a term, lists the words' — which tells the agent an argument-free invocation is valid and what it returns. It offers no guidance on when to prefer this over explain_issue, get_guide, or get_overview, all of which a confused agent might reasonably reach for first.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds the concrete endpoint and the fact that the signal comes from /health, which is genuine behavioral context. It stops short of saying what a negative result means (timeout vs. 5xx vs. degraded) or whether results are cached.

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

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

A single short sentence with zero waste, and the identifying detail (URL plus /health) is front-loaded. It reads as a fragment rather than a declarative sentence, which costs a little clarity but nothing in length.

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 parameters, an output schema absent but the return implied as a yes/no answer ('whether ... is answering'), and annotations carrying the read-only/open-world profile, the definition is nearly sufficient. The only gap is that an agent must infer the response shape and the meaning of a negative answer.

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 for the description to disambiguate; baseline 4 applies. The description correctly does not invent parameter discussion, though it could have mentioned that no arguments are accepted.

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 check ('Data API at https://api.iomarkets.tech ... from its /health check'), which unambiguously identifies a health-ping tool. It is a noun phrase rather than a verb+resource construction ('Check whether...'), and it doesn't explicitly name a contrasting sibling, but no sibling is plausibly confusable with a health check.

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

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

Usage is implied: 'right now' and the health endpoint signal this is a pre-flight liveness check before hitting data endpoints. However, it never states when to call it (before list_data_endpoints? on error?), nor any exclusions or cost/latency caveats relative to estimate_data_api_cost.

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

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

With readOnlyHint=true already covering safety, the description adds valuable context: it discloses that the seev.031 message is 'checked by the Test Bench' and reveals the inclusion of source provenance (filing and sentence/table row) and tokenized versions in the Asset Map. It does not cover error behavior or rate limits, but the annotation carries the safety profile.

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

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

The description is a single dense sentence that front-loads the core value ('One event in full') and then lists its components efficiently. It could be slightly more scannable with formatting, but every clause carries substantive information.

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

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

For a single-parameter detail tool with no output schema, the description thoroughly explains what the returned event includes, from raw dates and terms to the validated ISO 20022 message and tokenized representations. This gives an agent enough to understand the tool's output without an output schema.

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

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

Schema description coverage is 100% and the single id parameter is already well-documented in the schema. The description adds no additional parameter semantics, so the baseline 3 is appropriate.

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

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

The description clearly states that it returns one corporate action event in full, enumerating its components (dates, terms, filing source, tokenized versions, ISO message). It implies a detail-fetch counterpart to list tools but does not explicitly name or differentiate from siblings like list_corporate_actions.

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

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

Usage is only implied via the id parameter's schema description ('from list_corporate_actions or holdings_calendar'), which hints at the workflow but does not explicitly say when to use this tool versus the list tools or other alternatives. No when-not guidance is 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?

Annotations already declare readOnlyHint=true and openWorldHint=false, so the description only needs incremental detail. It adds the no-task listing behavior and tells the agent the output is procedural (exact button names), which goes beyond the annotations, though it says nothing about length or pagination of the guide content.

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

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

Two compact sentences with the primary behavior first and the no-argument fallback second. No filler, and the example list is short enough to inform without bloating.

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?

One optional enum parameter, no output schema, and annotations that cover the safety profile; the description supplies the missing output nature (step-by-step UI instructions) and the fallback behavior, so 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% and the single enum parameter already documents 'Leave out to list them all,' so the description's 'Without a task, lists the tasks' largely restates the schema. The parenthetical task examples hint at the enum's scope but add no per-value meaning.

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

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

States a specific verb and output shape: step-by-step instructions with exact button names for one task on iomarkets.tech, with concrete task examples (checking a message, CI, verifying a proof, Data API). The how-to/UI framing separates it from verification siblings like verify_proof or explain_term, though no sibling is named 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?

Explicitly covers both invocation modes: with a task it returns that task's instructions, without a task it lists available tasks. That is clear usage context, but it never says when a sibling such as explain_issue or get_sample is the better choice.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description adds useful content scope (which sections exist), but says nothing about response shape, length, or whether it is static versus live content. That is acceptable against the annotation baseline but not generous.

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

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

A single front-loaded sentence with no filler, and the enumerated content areas are genuinely informative. The phrasing 'what IoMarkets.tech is and what is built' is slightly awkward and could be tightened, but nothing 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?

With zero parameters, no output schema, and safety already carried by annotations, the description supplies enough to call the tool correctly. A note on return format or typical length would close the last gap, 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 there is nothing for the description to disambiguate; the baseline of 4 applies. The description does not mislead about inputs and confirms this is a no-argument read.

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 concretely enumerates what the tool returns: the ISO 20022 Test Bench, the Data API (x402-paid market data), main pages, and roadmap. That is much clearer than the tautological title 'What IoMarkets.tech is'. It stops short of distinguishing itself from siblings like get_guide and get_roadmap, which plausibly cover overlapping ground ('what comes next').

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

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

There is no statement of when to call this versus get_guide, get_roadmap, or get_api_status, even though 'what comes next' overlaps directly with a roadmap tool. The only hint is implicit (this is an orientation read), leaving the agent to infer routing from content lists alone.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so safety and locality are covered. The description adds useful provenance — the content mirrors iomarkets.org/roadmap — implying a static snapshot rather than live data, though it never says whether that snapshot can be stale. No auth, rate-limit, or response-shape details are given, which is acceptable given the annotation coverage.

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

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

One sentence, front-loaded with the content ('what has been built and is building next') followed by the provenance qualifier. Nothing is wasted and nothing important is buried.

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

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

With no parameters, no output schema, and read-only annotations, the description's main burden is telling the agent what comes back — and 'in the same words as iomarkets.org/roadmap' does that better than most. It stops short of saying the return format (text, markdown, link) or whether the roadmap is time-stamped.

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 for the description to disambiguate; the baseline for a no-param tool applies. Nothing in the description contradicts or complicates the empty 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 the resource precisely: the company's roadmap, both shipped and planned items. The phrase 'in the same words as iomarkets.org/roadmap' pins down the exact content an agent will receive, which is more specific than a bare 'get roadmap'. It does not, however, explicitly contrast itself with nearby siblings such as get_overview or get_guide.

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

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

There is no statement of when to call this versus get_overview, get_guide, or get_sample, all of which could plausibly answer 'what is this company about'. No prerequisites, no exclusions, no context beyond the content itself. The agent must infer that this is the right tool for roadmap questions.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description adds genuinely new context: every party and account is fictional, which tells the agent the payload contains no real data and is safe to embed in tests or examples. It does not describe error behavior for a bad id, but the closed enum largely removes that risk.

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

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

Two short sentences, no redundancy; the return type is front-loaded and the caveat about fictional data follows. Nothing to trim.

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 names the return format (XML of a single message), which is what an agent needs. Missing only the valid-versus-invalid distinction among sample ids, which matters because a caller expecting a usable baseline could pick a malformed sample.

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

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

Schema coverage is 100% and the single parameter is a closed enum, so the schema does the heavy lifting. The description reinforces that the id comes from list_samples, but it omits the most useful semantic detail: the enum mixes a handful of valid samples with dozens of deliberately malformed ones (e.g. pacs.008-unclosed-tag, camt.053-balance-mismatch). An agent must infer that from the id strings alone.

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: returns the XML of one sample message, drawn from list_samples. An agent can immediately tell this apart from list_samples (which enumerates ids) and from validate_message (which checks a message).

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

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

Gives concrete usage contexts — a starting point for authoring or for tests — and names list_samples as the source of valid ids. It stops short of stating when not to use it (e.g. against real traffic, or versus list_messages), but the intended purpose is unambiguous.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, and the description goes beyond them by disclosing the shape of the payload (chain-by-chain contracts, issuer provenance, signature verification outcome). It doesn't say what happens for an unknown id or whether the call is metered, which keeps it from a 5.

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

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

A single front-loaded sentence fragment that enumerates the returned content with no filler. It is dense but every clause maps to a real payload component; only the somewhat compressed phrasing keeps it from 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?

With no output schema, the description must carry the return-value burden, and it does so by listing the four content areas an agent will receive. Missing only lookup-failure behavior and any note about cost or side data, so it is nearly complete for a simple read-by-id tool.

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

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

Schema coverage is 100% with a full enum of ~80 allowed ids, so the schema already carries the semantics; the description's 'entry id, from list_tokenized_assets' merely restates it. Baseline 3 is appropriate, with no added format or edge-case guidance.

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 the resource ('One Asset Map entry') and enumerates exactly what it contains: the security, per-chain token contracts, issuer sources, and IoMarkets signature verification status. That is far more specific than a tautology, though it never explicitly contrasts itself with list_tokenized_assets or verify_asset_with_issuer.

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

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

Usage is only implied: the id parameter says 'from list_tokenized_assets,' so an agent can infer this is the detail-fetch following the list call. There is no explicit when-to-use/when-not statement and no pointer to alternatives such as verify_asset_with_issuer for signature questions.

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

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

Annotations already cover the safety profile (readOnlyHint=true, openWorldHint=false), so the bar is lower. The description still adds real behavioral value by disclosing what comes back: a day-by-day breakdown plus an iCalendar/webcal subscription URL intended to be handed to the user's calendar app, which the agent could not know 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?

Three short sentences, front-loaded with the input and output scope, then the default, then the return artifact. The final clause ('to give the user for their calendar app') is slightly wordy but carries genuine invocation intent, so nothing 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?

With only two parameters, no output schema and read-only annotations, the definition covers input format, default window, return shape and the calendar URL artifact. Minor gaps remain (behavior for unknown tickers, time zone of dates, pagination or size limits) but none would block a correct call.

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

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

Schema coverage is 100%, so baseline is 3, but the description earns an extra point by defining 'day' as any day within a Monday-to-Sunday week rather than a single day's data, which the schema's 'Any day in the week' only hints at. For holdings it merely restates the schema's ticker/CIK/FIGI list.

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

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

The description names a concrete resource set (ex-date, record date, payment date, effective date) scoped to a holder's tickers/CIKs/FIGIs over a one-week window, which is far more specific than the name alone. It implicitly separates itself from list_corporate_actions by being per-holding and calendar-week-scoped, but it never names the sibling it is not, so an agent must infer the boundary.

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?

'For a list of holdings ... in one week' plus 'this week by default' establishes the context of use, and the calendar-URL clause hints at the user-facing scenario. However, there is no explicit when-not guidance and no routing statement versus list_corporate_actions, get_corporate_action or token_corporate_actions, so the agent has to guess which corporate-action tool applies.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered and the description correctly adds context beyond it: data is extracted from filings, each event carries provenance (filing plus sentence/table row), and structuredContent includes a calendarUrl. It stops short of describing volume, pagination, or how far back coverage extends.

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: the resource and source come first, then the filter semantics, then provenance. The trailing iCalendar/calendarUrl sentence is somewhat tangential to the core list operation but does carry usable information, so it earns its place marginally.

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 does the work of explaining the return shape — per-event dividend/split/merger details, provenance links, and the calendarUrl field. Minor gaps remain around result limits and ordering, but an agent has enough to call 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%, so the baseline is 3, but the description adds meaning the schema lacks: 'days (any of an event's dates between from and to)' clarifies the from/to semantics, and holdings explicitly lists the three identifier formats. This is genuine added value over the terse schema strings.

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 specific resource and source ('Corporate actions of US-listed companies from their own SEC EDGAR filings') and enumerates the covered event kinds (dividends, splits, reverse splits, mergers). An agent can distinguish this list tool from the single-event sibling get_corporate_action and from token_corporate_actions 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?

It gives real filtering guidance — holdings by tickers/CIKs/FIGIs, days meaning any event date falls between from and to, and filtering by type. It does not explicitly say when to prefer this over get_corporate_action or token_corporate_actions, so alternative 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?

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is partly covered. The description adds meaningful context beyond annotations: pricing is in USDC and payment uses x402 on Algorand mainnet with no account required.

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

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

The description is a single, front-loaded sentence that states the resource, return contents, price unit, and payment mechanism without unnecessary 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 no-parameter discovery tool with no output schema, the description covers the key facts an agent needs: what is listed, what each entry returns, pricing, and payment context. It does not describe output structure in detail, but no output schema exists and the central purpose is covered.

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 no parameter meaning to document. Per the baseline for zero-parameter tools, a 4 is appropriate.

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

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

The description clearly identifies the resource: Data API routes at a specific base URL, including what each route returns and its price per call. It does not explicitly contrast with the sibling estimate_data_api_cost, but the purpose is specific and distinguishable.

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

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

There is no explicit guidance on when to use this tool versus alternatives such as estimate_data_api_cost or get_api_status. The description implies it is for discovering routes and prices, but does not state conditions, exclusions, or alternatives.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description adds that the payload is a static catalogue of types/versions plus their purpose, which is useful context, but says nothing about ordering, size, or whether the catalogue can change.

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

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

One tightly packed sentence with no filler, and the scoping qualifier ('the Test Bench checks') is placed early. Nothing could be removed 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?

For a no-argument, read-only, output-schema-less tool, the description carries the main burden and it does describe the shape of the returned items (type, version, purpose). The notable residual gap is the tension between the name 'list_messages' and a catalogue of message types, which could cause a mis-call.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate. Baseline 4 applies; the description's only relevant contribution is confirming the returned set is scoped to 'what the Test Bench checks'.

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 ISO 20022 message types and versions the Test Bench checks, along with their purpose. That is clear enough to know what you get back. It does not, however, differentiate from sibling list_* tools (list_samples, list_data_endpoints, list_corporate_actions), and the name 'list_messages' could mislead toward listing individual messages rather than the supported type catalogue.

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

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

There is no statement of when to call this versus alternatives, no prerequisite, and no exclusion. An agent might infer it should consult this before validate_message, but that inference is not supported by any text in 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?

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description usefully adds that the result set mixes valid and deliberately broken samples, each carrying an issue code, which tells the agent what to expect in the payload. It says nothing about ordering, pagination, or the size of the library.

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

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

Two short sentences with no filler; the content of the library is front-loaded and the sibling routing follows immediately. Nothing could be removed without losing 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 simple read-only list tool with no output schema and a fully documented parameter, the description covers what the tool returns and how to get the underlying XML. Only the absence of any note on result size or ordering keeps it from being fully complete.

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

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

Schema description coverage is 100% and the single optional parameter is a fully enumerated message-type filter documented in the schema itself. The description adds no further semantics about the filter, so the baseline of 3 applies — the schema does all the work here.

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

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

The description identifies the resource concretely — the Test Bench sample library — and specifies its contents: one valid message per type plus broken samples annotated with their issue codes. It also distinguishes itself from get_sample, which returns the XML. The only gap is that the listing verb itself is implied rather than stated.

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

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

The sentence 'Use get_sample for the XML' explicitly routes the agent to the correct sibling when the actual message payload is needed, which is the main ambiguity for a samples tool. It stops short of stating when to prefer list_samples outright (e.g., to discover which samples or issue codes exist), but the contrast is clear enough to act on.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description adds a useful data-quality caveat ('ISIN where the issuer gives it'), but says nothing about result volume, pagination, or ordering for a collection endpoint.

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

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

Two dense sentences with no filler: contents first, filtering second. Every clause carries information the agent needs.

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

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

With annotations covering safety and no output schema, the description adequately conveys what comes back and how to narrow it. The remaining gap is collection behavior (pagination, result limits), which an agent would want before calling a list endpoint.

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 only labels the single parameter as 'Filter text (optional)', so the description meaningfully compensates by naming the six accepted filter dimensions (issuer, name, symbol, ticker, ISIN, FIGI). It could still clarify matching behavior (exact vs substring, multi-field), preventing a 5.

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 (securities in the Tokenized Asset Map) and enumerates what each record carries (FIGI, ISIN, chains). An agent can distinguish it from the singular get_tokenized_asset by the plural/collection framing, though the description never explicitly contrasts with siblings.

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

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

The second sentence explains how to filter ('Optionally filter by issuer, name, symbol, ticker, ISIN or FIGI'), which implies usage, but there is no statement of when to reach for this list versus get_tokenized_asset or verify_asset_with_issuer.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so safety is covered. The description adds real behavioral context beyond them: the data source (the corporate actions feed), the gating precondition that the token must be Asset-Map-listed as a tokenized stock/ETF, and that each action is annotated with its effect on the token. It does not say what happens when the token is not listed.

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

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

One compact sentence carrying purpose, precondition and return contents, plus a short intent quote. Front-loaded with the eligibility constraint; no filler, though the quoted question is slightly redundant with the preceding clause.

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 2 required parameters, no output schema and read-only annotations, the description does the work of describing return contents (tracked security + each corporate action and its token impact). The one gap is undefined behavior for tokens that are not listed as tokenized stocks, which the description neither confirms nor rules out.

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

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

Schema coverage is 100%, so both parameters (chain enum, address) are already documented in the schema. The description reinforces that address is a token contract and that the token must be on a supported chain, but adds no formatting or chain-specific nuance, so baseline 3 applies.

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

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

States a specific verb+resource pair: it returns the tracked security and that security's dividends, splits and mergers for a given token contract. The scoping clause (only tokens the Asset Map lists as tokenized stock/ETF, e.g. xStock) cleanly separates it from generic siblings like get_corporate_action and list_corporate_actions.

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 trigger condition ("For a token contract that the Asset Map lists as a tokenized stock or ETF") and the user intent it serves ("I hold this token; what is coming?"). It stops short of naming alternatives or stating what to do for non-tokenized-stock tokens, so no explicit exclusions.

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

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

Adds real context beyond the readOnlyHint/openWorldHint annotations: the message is not stored, the message type is derived from the namespace rather than a required argument, and the return payload is described in detail (valid flag plus every problem with line, element path, stable code, plain reason). It stops short of disclosing limits or edge behavior such as oversized input, and the 'same code as <URL>' line is a provenance claim rather than behavioral information.

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: scope, then validation layers, then return shape, then side-effect guarantees. Minor waste in re-listing all eight message types already present in the enum, and the trailing URL reference earns little space for the agent.

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

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

With no output schema, the description correctly carries the return-value burden by describing the valid flag and the structure of each reported problem. Side effects and type-inference are covered; what is missing is anything about input size limits or failure modes when the XML is unparseable.

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

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

Schema coverage is 100%, so the baseline is 3; the description adds meaning beyond it by clarifying that type selection defaults to the namespace (making 'message' a read-only override) and by spelling out which rule families 'schema_only' skips (check digits, totals, cross-element rules, market practice). It never names 'schema_only' directly, so the mapping must be inferred.

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

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

States a specific verb ('Check') and a specific resource (one ISO 20022 XML message), then enumerates the eight supported message types and the two validation layers (base schema, then business rules). This is clearly distinguishable from siblings like list_messages or the verify_* tools, which do not validate ISO 20022 XML.

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

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

Usage is implied rather than stated: the tool validates a message you already have, and the 'XML' and 'message' params suggest pre-send checking. However, there is no explicit when-to-use vs. when-not, no mention of what to do with the resulting problems (e.g. route to explain_issue), and no guidance relative to siblings such as list_messages.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so safety and external-dependency are covered. The description usefully adds that it fetches live third-party sources and verifies *every* listed contract (all-or-nothing scope). It does not say what happens when a contract is missing, an issuer source is unreachable, or how expensive/slow the live check is.

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

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

A single dense sentence, front-loaded with the action and the sources, closing with the rationale for using it. No filler or restatement of the name.

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

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

The mutation/safety profile is covered by annotations and the parameter set is trivial, but there is no output schema, and the description never indicates what a result looks like (per-contract booleans, a list of missing contracts, an error on unreachable source). For a live verification tool, that omission meaningfully limits correct interpretation of the response.

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, with 100% schema coverage and a self-describing enum of entry ids, so the schema carries the load. The description adds that the id refers to a single Asset Map entry, but nothing beyond that (e.g., whether ids are ticker-like slugs or opaque keys). 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?

Specific verb ('Fetch ... and confirm') plus resource ('the issuer's own sources for one Asset Map entry'), and it names the concrete source types (contracts page, public API, stellar.toml). It does not distinguish itself from the nearby sibling check_token_contract or get_tokenized_asset, so an agent gets no explicit routing signal between them.

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

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

The clause 'so trust needn't rest on IoMarkets' implies the usage context: you call this when you want independent, first-party confirmation rather than a platform-sourced answer. There is no explicit when-to-use/when-not or named alternative (e.g., vs. check_token_contract), so the routing 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?

Beyond readOnlyHint/openWorldHint, it discloses that verification depends on a public Algorand indexer that IoMarkets does not run (an external third-party dependency the agent cannot control) and that it recomputes values with the API's own scoring rules rather than just echoing the report. It does not mention failure/timeout behavior when the indexer is unreachable, which is the main residual gap.

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

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

The essential scope is front-loaded in the first clause, and the closing sentences cover equivalence to the web page and the return shape. The central sentence is very long with many stacked clauses and could be split for readability, 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?

With no output schema, the description carries the return contract and does so ('returns each check, and the recomputed summary as structured data'). For a read-only verification tool with a single well-documented parameter, the only missing pieces are error/failure semantics when signature or indexer checks fail.

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

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

There is a single parameter with 100% schema description coverage, so the baseline is 3. The description reinforces the key semantic — pass the response body verbatim, as the whole {audit, summary, attestation} object — but adds no format detail beyond what the schema already states.

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

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

The description names a specific verb (check/verify) and a precisely scoped resource: the whole JSON body returned by POST https://api.iomarkets.tech/v1/proof/execution, enumerating the four checks performed (signature, on-chain USDC payment, row hash vs audit_sha256, recomputation). This clearly separates it from siblings like verify_proof and verify_asset_with_issuer, which operate on different artifacts.

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

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

The description makes the applicable context explicit — you use it on an execution report returned by that specific endpoint, and it performs the same checks as the public execution-check page. It stops short of naming exclusions or pointing to a sibling when the input is something other than a full execution report (e.g. a bare proof, which would go to verify_proof).

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

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

Annotations already establish read-only and open-world behavior, but the description adds meaningful context: it verifies an ed25519 signature against the published IoMarkets key and checks USDC payment confirmation on Algorand mainnet via a public indexer IoMarkets does not run. It does not describe return values or 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?

The description is a single front-loaded sentence that states the action before the verification criteria. It is dense with parenthetical detail but has no wasted sentences.

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 verification tool with no output schema, the description explains what is checked but not what a successful or failed verification returns. Input, signature, and payment-confirmation context are covered, but result shape and error behavior are left unspecified.

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 proof parameter is already documented. The description reinforces that the proof is { payload, signature } JSON text, but adds no syntax or validation details beyond what the schema provides, matching the baseline for a fully described 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?

The description uses a specific verb and resource: check a signed proof. It also defines the proof as the { payload, signature } JSON returned by a Data API proof route, which distinguishes it from generic validation siblings like validate_message or verify_execution_report.

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

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

Usage is implied by 'the { payload, signature } JSON a Data API proof route returns,' so an agent can infer this is for verifying proof-route output. However, the description gives no explicit when-to-use/when-not-to-use guidance or named alternatives among the sibling verification tools.

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