Council of AI GSPC

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

The description discloses far beyond the annotations: payment requirements, the 402 challenge flow, the free unsigned preview behavior, the NOT_DEPLOYED fallback, and the limitation that watermarks are UNCHECKABLE when no public detector exists. This gives an agent realistic expectations for success and failure modes, with no contradiction against 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?

The description is dense and jargon-heavy, but each sentence carries a distinct operational fact: payment, detection scope, preview behavior, 402 handling, and deployment fallback. It is front-loaded with the PAID gate and avoids filler, though the opening endpoint URL could arguably be omitted without losing value.

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

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

For a complex paid tool with a 402 flow, the description covers the essential invocation behaviors: payment, free preview, unsigned output, and honest failure modes. An output schema exists, so return-value documentation is not required. The only notable gap is explicitly guiding which of url, bytes_b64, or manifest_b64 to provide, but the schema's 'Alternatively' labels already cover that distinction.

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 meaningful semantics for x_payment (it is the signed challenge response required to proceed) and preview (free and returns the same measurement unsigned), which are not fully captured by the schema field descriptions alone. Other parameters remain schema-level but are already well described there.

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 (Article 50 marking-evidence pack) and the core operation: detecting whether a machine-readable mark is present in given bytes, along with Art 50(2) and Art 99(4) hashes. It is distinguishable by its explicit point-in-time detection scope, though it does not explicitly contrast itself with sibling tools like rwa_evidence or verify_inclusion.

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 strong usage context: the tool is paid, requires x402 or an invoice, preview=true provides a free unsigned path, and omitting x_payment triggers a 402 challenge. It also states what the tool will never do (conformity opinion/compliance word), but stops short of naming alternatives or saying 'use this when you need X instead of Y'.

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 description discloses critical behaviors beyond the annotations: the two numbers are never summed or swapped, a distinct UNREACHABLE state is returned on fetch failure, and no cached number is presented as live. These details significantly inform an agent's expectations, complementing the readOnlyHint and openWorldHint 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?

The description is somewhat long but every sentence contributes meaningful context. It front-loads the core purpose and then elaborates on the distinct numbers and failure behavior. It could be tightened slightly but remains efficient and well-organized.

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 not showing the output schema, the description fully specifies what is returned (slot count, measured count, as_of dates) and covers edge cases (unreachable state, no caching). This is comprehensive for a zero-parameter tool with a simple 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?

The tool takes no parameters, so the baseline of 4 applies. The description adds no parameter-specific details because none exist, and it properly focuses on the output semantics instead.

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 tool's purpose: returning live GSPC board totals from a specific URL, with explicit distinction between slot count and measured count. It also sets it apart from siblings by emphasizing the 'live' nature and the unreachable state, making its function unmistakable.

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 does not explicitly name alternatives or provide when-not-to-use guidance, but its specificity makes the intended use obvious: for retrieving current board totals. The absence of exclusions is acceptable given the tool's narrow, well-defined scope.

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 annotations by disclosing the paid x402 nature, the re-serving behavior, and that 'a payment never mints a MEASURED cell (fresh_run stays UNMEASURED until a published run exists).' Also describes the no-payment fallback response and the semantic boundary against certification.

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 but every sentence earns its place: main action, payment semantics, challenge mode, and scope boundaries. Front-loaded with 'PAID (x402)' and the core action before caveats.

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 paid x402 tool with three parameters and an output schema, the description covers the full call flow: challenge without payment, completion with payment, effects on existing cards and fresh_run, and the boundary against certification. 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%, so the baseline is 3, but the description adds behavioral meaning to the parameters: the x_payment challenge/response flow, what 'subject' can be (model id, instrument id, card sha), and the effect on fresh_run state. This goes beyond the schema's property 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 the specific action 'Commission one signed card-v0 receipt' for a named subject on the frozen bank, via a concrete endpoint. It also draws clear boundaries: 'Measurement, not certification — never a rank, a grade or a certificate,' distinguishing it from verification and certification tools in the sibling list.

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?

Explains the two-step usage: omit x_payment to get the 402 challenge and free preview, then supply x_payment to complete. It excludes certification and notes 'Verification stays free,' steering agents toward free verification alternatives, though it does not name the specific sibling 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 already mark the tool read-only and idempotent, and the description adds rich behavioral context: unmeasured axes are valid first-class responses, not errors or zeros; unknown names return a list of board names; and responses come from a live board URL. There is no contradiction with 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?

The description is front-loaded with the core operation and packs useful detail into three sentences. It is slightly dense in the middle, where the row fields follow the axis-id clause, but every part 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 one-parameter read-only tool with an output schema and strong annotations, the description covers lookup behavior, edge cases such as unmeasured axes and unknown names, and the data source. Nothing an agent needs to correctly invoke it is missing.

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

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

The input schema has 100% coverage for the sole parameter, including case-insensitivity and the unknown-name fallback. The description reinforces exact board spelling and the fields returned, but it does not materially change the parameter's meaning beyond what the schema already provides.

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

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

The description opens with a concrete action and resource: returns one axis row from the live GSPC board. It lists the row's fields and clarifies that it is a single-axis lookup, not a board-level or card-level operation. The 'Never a certification' line further sharpens the tool's purpose.

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 clearly establishes that this is a single-axis lookup by exact board id, but it does not name sibling alternatives or explicitly state when to choose this over board_totals, list_cards, or get_card. The 'Never a certification' line gives one negative boundary, so usage 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?

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false. The description adds valuable behavioral context: the three states (VALID, INVALID, UNCHECKABLE), the visible UNMEASURED cells, and the source URL. This goes beyond the annotations without contradicting them.

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 compact, front-loaded with the action and resource, and every sentence contributes: the URL, the states, and the exclusion of GSPC measurement cards. No filler or redundancy.

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

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

An output schema exists, so return values need not be described. The description covers the states, the URL, and the card type, and the annotations handle safety. It is sufficiently complete for a single-card fetch, though it could briefly mention alternatives (addressed in usage guidelines).

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 input schema already documents the parameter (64-char hex SHA-256) with 100% coverage, so the description repeats that. It adds the URL pattern and confirms the purpose, but no new semantic meaning beyond the schema. Baseline 3 is appropriate given high schema coverage.

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 (GET), a precise resource (card-v0 leaf), and the exact identifier (sha256 hex). It also distinguishes itself from a sibling class ('Not a GSPC measurement-card'), making its purpose unambiguous.

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

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

The description implies usage for fetching a specific public-root card by hash and clarifies it is not a GSPC measurement-card, but it does not explicitly contrast with other siblings like verify_card or get_root. There is no 'use this when' or 'instead of' guidance, leaving some ambiguity for an agent choosing among related tools.

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

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

Beyond the readOnlyHint and idempotentHint annotations, the description discloses operational states (VALID, UNREACHABLE, UNCHECKABLE), clarifies that it never returns a certificate, and notes the permissionless nature. This adds meaningful behavioral context about failure modes and output guarantees.

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 three sentences with no filler. The main action and URL are front-loaded, followed by return fields and states. Every sentence earns its place and the text is highly efficient.

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

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

For a zero-parameter GET tool with an output schema (as indicated), the description covers the endpoint, return fields, and state behavior. The term 'UNMEASURED notes' is cryptic and could be clarified, and usage guidance is minimal, but overall the tool is simple enough that this is sufficient.

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

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

The tool has zero parameters, so the description need not elaborate on parameter semantics. The baseline for no-parameter tools is 4, and the description correctly omits any irrelevant parameter detail.

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 the tool fetches the permissionless public Merkle root from a specific URL, lists the exact return fields (merkle_root, card_count, as_of, UNMEASURED notes), and distinguishes it from GSPC and from being a certificate. The verb 'GET' plus resource and expected output make the purpose unambiguous.

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

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

The description notes 'Separate from GSPC' which hints at a distinction, but it does not explicitly state when to use this tool over its siblings (e.g., get_axis, verify_inclusion). No alternative tools are named and no conditions for selection are given, leaving usage inference largely to the agent.

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

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

Annotations already establish read-only, idempotent, non-destructive behavior, so the description's added value is the countable behavioral nuance: it shows disagreement rather than picking one, and the counts are 'reported next to' each other rather than merged. It also discloses that filters only affect rows, not the two full counts, which is useful beyond the schema.

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

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

The description is front-loaded with the resource URL and the core comparison behavior, and every sentence contributes meaning. The first sentence is somewhat dense with nested clauses, but that density is justified by the nuanced behavior it must convey.

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 an output schema present and full parameter schema coverage, the description needn't explain return values or parameter syntax. It adequately covers the tool's distinguishing behavior, the never-reconcile boundary, and the filter behavior, leaving no major gap for invocation decisions.

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 input schema already documents both axis and limit. The description merely restates them as 'Optional filters return recent rows: axis, limit' and adds no new parameter-level detail beyond the schema.

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

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

The description names the resource ('published signed-card index'), the verb ('list'), and a highly specific behavior: reporting the declared n_cards, the actual row count, and the card-store endpoint count side by side without reconciling them. This is far more than a restatement of the title and clearly separates it from generic card-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?

It gives a clear context for use by explaining that the tool intentionally reports two counts from two surfaces and 'never reconciles' them, so an agent knows it should not be used when a single reconciled answer is needed. However, it does not explicitly name sibling alternatives or say 'use X when Y', so it stops short of full routing guidance.

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

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

Annotations already mark the tool read-only, open-world, idempotent, and non-destructive. The description adds substantial behavioral context beyond that: host details are withheld by design, partial rounds or cap changes are disclosed, it is measurement rather than certification, and the three possible states are defined. This is exactly the kind of transparency that helps an agent set expectations.

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 compact and front-loaded, leading with method, resource, and URL before moving to the counts. Every sentence earns its place: scope, privacy caveat, disclosure caveat, epistemic caveat, and state definitions are all conveyed without 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?

For a zero-parameter read-only tool with rich annotations and an output schema, the description covers all essential context: what is counted, how states are classified, what caveats exist, and what limits apply. Nothing needed to call it correctly or interpret its result 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 has zero parameters, so there is nothing for the description to explain beyond the baseline. Schema coverage is effectively 100% and the empty parameter object is self-explanatory.

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 ('GET'), a specific resource (the latest MCP handshake trust snapshot), and gives the exact URL. It then enumerates what the snapshot contains, so an agent knows unambiguously what this tool does and can tell it apart from related census-style 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 description makes the tool's context clear: use it when you need internet-facing MCP handshake trust counts by doctrineches. However, it never explicitly says when to use this tool versus alternatives like x402_trust, nor does it state any exclusions or fallback conditions.

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 description goes well beyond the readOnly/idempotent annotations by disclosing concrete behaviors: re-verifying the board signature against pinned did:web:csoai.org#board-attestation-1, never calling PENDING attested, and defining NOT_PUBLISHED and UNREACHABLE fallback states. This gives an agent accurate expectations for the operation's result semantics. No contradiction with the readOnlyHint=true annotation.

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 run-on sentence with a long colon-delimited enumeration, making it structurally unwieldy despite containing no wasted words. Front-loading the verb and resource is good, but the content would be more digestible as shorter sentences or bullet points.

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

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

Given the presence of an output schema that presumably defines return fields, the description covers the source URL, the read scope, verification behavior, semantic limitations, and edge-case states. An agent has enough information to decide whether to call this tool and what to expect, with nothing substantial 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 has zero parameters and schema coverage is trivially 100%, so the baseline of 4 applies. The description adds context about the fixed source URL and the verification performed, which substitutes for parameter-level guidance since no parameters exist to document.

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 verb and resource: 'Read the latest signed measurement-capsule index published at https://councilof.ai/measurement-capsules/latest.json'. It enumerates the precise contents read (index root, batch fields, board signature re-verification, anchor states), which clearly distinguishes it from sibling verification tools that target individual capsules or cards.

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 provides strong contextual scope, such as 'States only: measurement, not endorsement; no verdict, score or ranking' and the NOT_PUBLISHED/UNREACHABLE conditions, which help an agent infer when the tool is appropriate. However, it never names sibling tools or explicit when-to-use/when-not-to-use conditions like 'use verify_capsule instead for a single capsule'. Usage is implied by scope rather than stated directly.

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 annotations, the description reveals payment behavior, the 402 challenge, the preview mode, the exact sha256 preview, and the fact that the batch covers up to 200 leaves. It also discloses that the tool never claims a settlement-receipt stream, which is important context not available from 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?

The description is dense but information-rich, and it front-loads the payment requirement and historical nature. It is a single paragraph and includes a slightly metaphorical phrase, but every sentence contributes meaningful operational guidance.

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

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

Given the tool's complexity—paid access, x402 flow, preview mode, output structure, and archival scope—the description covers all essential aspects. It explains preconditions, return contents, free alternatives, limitations, and explicitly warns against misinterpreting the batch as a settlement stream.

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 meaning: from/to are window bounds against leaf as_of, preview=true returns count/span/root count/batch sha256, and x_payment is the signed header from the previous 402 challenge. This goes beyond the raw schema 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?

The description states a specific verb and resource: it returns a historical batch of estate measurement receipts for a given [from,to] window, with inclusion paths and root information. It distinguishes itself from siblings by explicitly saying recent leaves are free elsewhere and that the batch sells assembly across history, not a conclusion.

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 explicitly tells the agent when to use the paid batch versus free alternatives: preview=true is free and summarizes the call, while recent leaves are free via /root.json, /cards/, and /api/proof. It also states that without x_payment the tool returns the 402 challenge, and clarifies that no settlement-receipt stream exists.

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 description goes far beyond annotations, disclosing the x402 payment flow, the deterministic state contents, the 'unreachable is never FAIL' rule, the sha256 hashing of raw fetches, the historical fetched_at semantics, and the NOT_DEPLOYED behavior. This is rich behavioral context that annotations do not provide.

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

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

The description is dense but front-loaded with the most important fact ('PAID (x402)') and each clause adds useful detail. It is somewhat long and run-on, but every sentence earns its place for a tool with a payment flow and multiple behavioral caveats.

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

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

Given the x402 payment complexity, the output schema already exists, and the description covers payment, preview, failure modes, deployment status, and what the evidence is not, the definition is complete enough for an agent to invoke the tool correctly.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaningful semantics beyond the schema by explaining that preview=true yields free unsigned state and that omitting x_payment returns the 402 challenge. This helps the agent understand the payment handshake.

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 'PAID (x402). Per-request signed evidence card of ONE XRPL issued asset's deterministic on-ledger state' and names the exact endpoint. It clearly identifies the resource and the operation, and the 'not a rating, not a guarantee, not a conformity mark' phrasing helps distinguish it from certification-style sibling 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?

The description gives clear usage context: it is paid, preview=true is free, and omitting x_payment returns the 402 challenge. It does not explicitly name sibling alternatives or state when not to use it, so it stops short of full exclusion 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 mark readOnlyHint, openWorldHint, idempotentHint, and non-destructive. The description goes beyond these by specifying concrete behaviors: an unmeasured endpoint returns NOT_MEASURED with an empty list, never an error and never a clean bill; there is no verdict, score, or ranking; and the shard key is a sha256 of the normalized URL. This materially enriches the safety and expectation 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 dense but logically organized: core purpose first, then capsule contents, retrieval mechanics, empty-result semantics, and a closing non-endorsement caveat. Every clause carries substantive value, though the length and technical density could be hard to parse at a glance for a simpler 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 one simple parameter, a rich output schema, and annotations covering safety and world-openness, the description supplies all remaining decision-relevant context: empty-list vs NOT_MEASURED behavior, the inclusion verification pointer, and the per-batch origin of capsules. 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?

The schema documents endpoint_url with a clear example, and coverage is 100%. The description adds meaningful usage context—normalization via sha256 and single-endpoint scoping—which helps the agent understand how the parameter drives the lookup, even though the format is already well-specified.

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 reading operation: 'every published measurement capsule about ONE endpoint URL across all batches' and 'Read from a static per-endpoint shard'. It clearly differentiates this tool from aggregate-focused siblings like board_totals and from verification-only tools like verify_capsule, so an agent can tell what unique value this tool provides without opening schemas.

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

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

The opening 'Trust per server, not totals' signals when to prefer this over aggregate views, and the mention of verify_capsule re-deriving inclusion points to the verification alternative. It does not explicitly list when-not-to-use or name an exclusion, but the context is clear enough for an agent to choose sensibly.

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 mark this as read-only, idempotent, and non-destructive, and the description adds substantial detail beyond that: recomputing capsule_id, picking the schema rule, finding the published batch, recomputing the root, and returning an audit path. It also discloses all possible output states and the semantic limit that verification is proof of publication, not endorsement. No contradiction with 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?

The description is dense and information-rich rather than padded, front-loading the core action and input requirement. The caveat about measurement vs endorsement adds value; the enumerated output states are slightly redundant with the output schema but still useful in a single glance.

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

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

For a single-parameter, read-only tool with an output schema, the description is fully sufficient. It covers the input format, the verification algorithm, all result states, cost, and semantic limitations, leaving no critical operational knowledge 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 schema covers the single parameter 100%, providing a baseline of 3. The description adds meaningful nuance by explaining that JSON text is preferred for byte-exactness and that number lexemes are preserved, which helps the agent choose the correct input form.

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 verb and resource, 'Verify one measurement capsule', and then defines the exact domain and schema ('csoai.measurement-capsule/0.2'). This distinguishes it clearly from sibling tools like verify_card and verify_inclusion, and it does not merely restate the title.

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 input guidance: pass capsule_json as byte-exact JSON text or an object. It also explains what verification proves and what it does not prove. However, it does not explicitly contrast this tool with siblings such as verify_inclusion, so the when-to-use-vs-alternative guidance is implicit 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and openWorldHint=true, and the description adds substantial context beyond that: the exact verification algorithm, the security reasoning about self-signed keys, and the three-verdict semantics (VALID, INVALID, UNCHECKABLE). This goes beyond what annotations provide and fully discloses the tool's 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 slightly long but well-structured: it starts with the core action, then explains the verification process, the security nuance, and the verdict semantics. Each sentence earns its place, though it could be tightened by moving the URL reference to the end. It is not wasteful, and the critical information is front-loaded.

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

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

Given the complexity of signature verification and the need to handle security pitfalls, the description covers all essential aspects: how the verification works, what makes a card INVALID, what UNCHECKABLE means, and acceptable input types. Since an output schema exists, return-value details are not required. An agent has sufficient information to call this tool correctly.

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

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

The single parameter 'card' is fully described in the schema (100% coverage) as accepting an object, JSON string, or URL. The description adds the negative constraint 'Never a certification,' which clarifies what the tool does not accept, providing extra semantic value beyond the schema. This raises it above the baseline 3.

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

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

The description states a specific verb (verify), a specific resource (signed gspc.measurement-card), and a precise method (recompute id, check Ed25519 signature under pinned key). It distinguishes itself by explicitly stating it is not a certification and by defining three verdicts, which separates it from generic verification tools like verify_inclusion.

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 clearly explains when to use the tool (to verify a signed measurement card) and what it does not do ('Never a certification'). It also clarifies the nuance of UNCHECKABLE vs INVALID, which guides correct interpretation of results. However, it does not explicitly name alternative tools or specify when to choose this over verify_inclusion, though the focus on measurement cards is 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?

Annotations already provide readOnly, idempotent, and non-destructive hints, and the description adds substantial behavior beyond those: the exact HTTP GET mechanism, the three-state output contract (VALID, INVALID, UNCHECKABLE), the failure mode for an unreachable endpoint, and limitations around Ed25519. This is rich, non-redundant 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?

Three sentences, each carrying unique information: the action and endpoint, the allowed return states, and the explicit non-claims. The most important information 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?

With a single well-documented parameter, complete annotations, and an output schema, the description still covers the essential behavioral details an agent needs: the endpoint, the three possible outcomes, and the failure mode. Nothing required for correct invocation is missing.

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

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

The input schema already fully documents the only parameter as a '64-char hex digest', so schema-description coverage is 100%. The description does not add parameter-level meaning beyond the schema, so the baseline of 3 applies.

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

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

The description states a specific verb and resource: 'Check a sha256 against the live public-root merkle via GET /api/proof?sha='. It also distinguishes itself from sibling tools by explicitly excluding Ed25519 claims and grading, making its scope unmistakable.

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 exclusions: it does not claim Ed25519 and is never a grade, which tells an agent when not to use it. However, it does not name an alternative sibling tool or state a positive 'use this when...' condition, so it stops short of fully explicit 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?

The description adds meaningful behavioral context beyond the annotations: host details are withheld, counts are doctrine-only, and a 402 is explicitly not delivery. These caveats clarify both scope and limitations in a way the schema and annotations alone would not convey.

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 entire definition is a single dense sentence that front-loads the operation and resource, then packs essential caveats into semicolon-separated clauses. Every phrase earns its place; there is no redundant wording.

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

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

For a zero-parameter read-only snapshot with an output schema, the description is fully adequate. The annotations cover safety and idempotence, and the description covers semantic limitations. Nothing needed to call this tool correctly is missing.

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

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

The tool has zero parameters and 100% schema coverage, so the description has no parameter burden. The baseline of 4 applies; the description appropriately makes clear this is a no-input snapshot call.

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

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

The description clearly identifies a specific verb ('GET'), a specific resource ('x402 catalog trust snapshot'), and the exact data being returned (counts of correct 402 challenges vs phantom resources). It is distinct from sibling tools like mcp_trust by focusing on x402 catalog counts, not general trust or individual records.

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

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

The description implies when to use this tool: when you need aggregate x402 catalog trust counts by doctrine. It also warns 'measurement, never certification,' suggesting it should not be used for certification decisions. However, it does not explicitly name alternatives or state exclusion conditions, leaving some inference required.

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