Council of AI GSPC

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

With annotations present (readOnlyHint=false, openWorldHint=true), the description goes well beyond them: it discloses the paid x402 flow, the 402 challenge behavior, the point-in-time/caveat semantics (NOT_DETECTED != unmarked, metadata often stripped), the C2PA membership disclosure, and the explicit refusal to render conformity/compliance opinions.

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 front-loaded, leading with PAID and the core detection claim before scope, caveats and payment mechanics. Most sentences carry distinct weight, though the run-on structure and repetition of the payment/preview point cost it a top score.

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 explained. The description covers the remaining burden for a paid, network-fetching, point-in-time measurement tool: scope limits, failure modes, payment handshake and evidentiary caveats are all present.

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

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

Schema description coverage is 100% with zero required parameters, so the schema already documents url, preview, bytes_b64, x_payment and manifest_b64. The description reinforces the payment semantics (x_payment omission yields the challenge; preview is free/unsigned) but adds no syntax or format 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?

Names a specific verb (measure/detect) and resource (Article 50 marking-evidence pack) and immediately bounds the scope: 'which machine-readable marks the named methods DETECT in these bytes right now. Scope: C2PA and IPTC metadata only.' It explicitly excludes watermark/fingerprint marks, so an agent can tell it apart from other evidence 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?

Gives clear operating conditions: preview=true is free and unsigned, omitting x_payment returns the 402 challenge, and an undeployed route returns NOT_DEPLOYED. It does not, however, explicitly route the agent among siblings such as evidence_bundle, rwa_evidence, or server_evidence.

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

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

Annotations already cover safety (readOnly, idempotent, non-destructive, openWorld), so the bar is lower, and the description adds genuinely new behavioral context: slots and measurements are never summed or swapped, and an unfetchable board yields a distinct UNREACHABLE state with no cached number ever shown as live. That failure-mode disclosure is the kind of detail annotations cannot express.

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

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

The first sentence front-loads purpose and source well, but the body is a long chain of em-dash-appended clauses that mixes return-value definition, parameter selection, and a mission statement ('We measure, never certify'), which borders on redundant given the output schema exists. It is readable but heavier than the single-parameter, output-schema-backed tool 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 an output schema present, return values need not be spelled out, yet the description covers the semantic pitfalls (slot vs. measurement, never summed) and the error state, which are the pieces structured fields cannot carry. Only the routing among sibling evidence tools is left unexplained.

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

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

Schema description coverage is 100% and the single enum parameter is fully documented in the schema, so baseline 3 applies. The description's detail="full" clause largely restates the schema ('count_grammar, per-family counts, measured_on block') rather than adding format or cost semantics.

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

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

The description states a specific resource (live GSPC board totals) with a concrete verb-equivalent (fetch/return) and enumerates exactly what comes back: slot count, measured count, separation line, and as_of dates. It does not, however, differentiate itself from the many sibling evidence/trust tools (measurement_index, get_axis, get_card), leaving the agent to infer the distinction.

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 tool is the way to read board totals, and the description tells the agent to pass detail="full" for the long-form grammar and per-family counts, which is a useful selection cue. But there is no explicit when-to-use vs. siblings or when-not to use it, so guidance stays at the implied level.

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 declare readOnly/openWorld/idempotent/non-destructive, and the description still adds real behavioral context: the source is fetched live, results are never a satisfied/not-satisfied determination, zero relevant cards returns EMPTY rather than an error, and article-53 output is evidence for review only. These edge-case and non-determinism semantics are exactly what annotations cannot 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?

It is dense and front-loads the resource and scope, and each disclaimer (EMPTY semantics, no determination, grants no status) carries load. The third and fourth sentences overlap somewhat in re-stating the non-certification boundary, which is minor redundancy rather than padding.

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

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

An output schema exists, so return structure need not be described, yet the description still covers the two cases an agent must handle correctly — zero relevant cards (EMPTY, not an error) and the non-determinative nature of relevance. Combined with the documented enum and subject semantics, nothing needed to call this correctly is missing.

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

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

Schema description coverage is 100% and the enum values for obligation are fully documented in the schema, so the baseline is 3. The description restates the subject concept ('a model id, vendor or instrument the cards must name') and confirms the obligation-wide selection when omitted, but adds little beyond the schema text.

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

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

The description names a specific verb+resource and scope: the obligation record, its counsel-gate status, and the already-signed measurement cards relevant to exactly ONE obligation, read live from a named endpoint. It also constrains the selection to one of four obligations, which separates it from card-level siblings like get_card or list_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?

It gives clear context for use (obligation-level evidence for a single obligation, optionally narrowed by subject) and explicitly rules out use as a conformity assessment, certification, audit opinion or compliance determination. It does not, however, name a sibling tool or state when to prefer this over measurement_index or list_cards, so routing guidance is partial.

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 readOnly, idempotent, openWorld and non-destructive, so safety is covered. The description adds genuinely new behavioral context: the four outcome states (VALID, NOT_IN_THIS_CORPUS, INVALID, UNCHECKABLE) and that UNMEASURED cells remain visible. This goes well beyond the annotations, though the states partly overlap with the output schema.

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

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

Front-loaded with the core action and key format, followed by state semantics and the sibling routing. Dense and telegraphic but nearly every clause earns its place; the state enumeration is the only portion that could be considered verbose.

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 re-explained, and the single parameter is fully covered by the schema. The description still supplies state meanings, an alternative-tool route, and a scope exclusion, leaving nothing an agent needs in order to call it correctly.

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

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

Schema coverage is 100% and the param already documents the 64-char hex requirement, so the baseline is 3. The description adds the URL construction detail, showing the payload id maps to {sha16}.json, which is extra meaning beyond the schema, though the sha16 truncation is only implied and slightly ambiguous.

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

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

States a specific verb (GET), resource (one public-root card-v0 leaf), and lookup key (sha256, 64 hex) plus the exact endpoint pattern. It is clearly distinguishable from siblings like get_root, list_cards, and verify_card.

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

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

Provides explicit routing for one state: when the id is NOT_IN_THIS_CORPUS, the agent is told to use verify_card instead. It also excludes GSPC measurement-cards. However, it gives no general when-to-use guidance versus verify_card or list_cards for the common case.

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 declare readOnly, idempotent, non-destructive, openWorld, so the safety bar is met. The description adds genuinely useful behavior: the two counts are reported next to each other and deliberately never reconciled, and rows are returned newest-first with the full counts reported regardless of the limit. That is meaningful context beyond the annotations, though it does not mention rate limits or the size of the index.

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

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

Four sentences that are information-dense to the point of being hard to parse, with em-dash-heavy asides. The purpose is front-loaded, but the reconciliation caveat and the counts-regardless-of-limit note are repeated from the schema, so not every clause 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?

With an output schema present, return-value shape need not be spelled out, yet the description still explains the index's declared-vs-actual count semantics and how to chain into verify_card. For a two-optional-param read tool this is close to complete; only the index's scale and pagination beyond 'newest first' are unaddressed.

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

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

Schema description coverage is 100%, so the baseline is 3. The description names axis and limit and notes they return 'recent rows' newest-first, but this largely restates what the schema already documents, including the schema's own note that the two counts are always reported in full regardless of the limit.

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: list the rows of the published signed-card index, and report the declared count (n_cards) alongside the actual row count. It distinguishes itself from the card store endpoint and names verify_card as the follow-on tool, so an agent can place it. The dense, clause-heavy opening sentence slightly muddies the core action.

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 says optional filters (axis, limit) return recent rows and that card_url or the row's card id should be passed to verify_card for verification, which gives implied routing context. However, it never states when to reach for this tool versus siblings like get_card, board_totals, or measurement_index, so usage is only inferable.

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?

Annotations already declare readOnly=true/idempotent=true/destructive=false, and the description reinforces rather than contradicts these. It adds substantial beyond-annotation context: task text is hashed and never stored, nothing is executed/called/charged, unknown policy keys grant nothing, unmeasured candidates are UNTESTED (never 0), sponsor/bid/placement are ignored, and separation-of-leader semantics for declared candidates.

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

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

It is a dense block but front-loads the core purpose and each sentence carries operational meaning (UNTESTED rules, tie_break, hashing, NOT_ENABLED). Some mild repetition of 'free, decide-only' from the title, and the run-on paragraph could be broken up, but waste is low for a tool of this complexity.

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 no prose. For an 8-parameter tool with nested policy/objective/candidate objects and an open-world routing decision, the description covers the decision rules, failure/degenerate outcomes, and privacy behavior an agent needs to call it correctly.

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

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

With ~75% schema coverage the baseline is 3, but the description adds real meaning: it enumerates policy presets, explains tie_break ordering, notes the quality axis reads the live board, describes data_class routing, and warns that an unknown candidate field makes it UNCHECKABLE while sponsor fields are ignored. Only the objective weights values (cost/latency/quality) go unexplained.

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

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

States a specific action (applies YOUR policy + the fixed GSPC floor to a candidate set) and a specific return (the chosen candidate, the basis, and an unsigned route record). This is clearly distinguishable from read-only siblings like board_totals, get_axis, and the verify_* tools. An agent can tell what this does without opening the schema.

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

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

Explains when it applies: candidates default to GSPC MCP tools or ones you declare; with none declared the tool matching the task purpose is chosen; when nothing matches the answer is UNTESTED. It also flags that mode=execute answers NOT_ENABLED, steering callers to decide. It never names a sibling as an alternative, but the usage conditions are concrete and 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?

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 cover safety (readOnly, idempotent, non-destructive, open-world), and the description adds substantial behavior beyond them: the static shard keyed by sha256 of the normalised URL, the NOT_MEASURED-with-empty-list contract ('never an error and never a clean bill'), the explicit absence of verdicts/scores/rankings, and the inclusion of Merkle root and inclusion pointer for independent verification.

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

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

Front-loaded with the operative framing ('Trust per server, not totals') and every sentence carries information rather than filler. The first sentence is very long and packs a parenthetical enumeration of dimensions, which costs some readability but does not waste space.

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 tool has an output schema, so return values need no prose, yet the description still covers the empty/absent case, the state taxonomy fields, and verification affordances. Nothing an agent needs to call this correctly is missing.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real semantics by explaining the URL is normalised and hashed to select the shard, implying case/trailing-slash variants resolve to the same capsule set. That goes beyond the schema's format/pattern constraints.

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

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

States a precise verb+resource ('every published measurement capsule about ONE endpoint URL across all batches') and enumerates the capsule families returned, which clearly separates it from aggregate siblings like board_totals and from verify_* tools that validate a single capsule. An agent can tell it apart from the other evidence tools without opening the schema.

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

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

'Trust per server, not totals' implies it is the per-endpoint counterpart to the totals tools, which gives useful framing. But no alternative tool is named and no explicit when/when-not condition is stated, so routing versus mcp_trust, measurement_index or verify_capsule 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 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?

Goes well beyond the readOnly/idempotent/openWorld annotations by disclosing the pinned-key model, the trust distinction between inline keys and DID references, and the three-verdict outcome model (VALID/INVALID/UNCHECKABLE). This is exactly the kind of behavioral detail an agent needs to interpret results and avoid treating 'could not check' as forgery.

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

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

Front-loaded with the core action and the rule link, and every clause conveys substantive information. It is a dense single block rather than cleanly segmented, which slightly hurts readability but not content economy.

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?

Output schema exists so return values need not be explained, and the description still covers verification mechanics, key trust boundaries, verdict semantics, and input resolution. Nothing an agent needs to invoke or interpret the tool is missing.

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

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

Schema coverage is 100% and the single param's anyOf forms are already documented, so the baseline is 3. The description adds meaning by tying the id form to its origin ('the record id shown on the site and the card field of list_cards') and to the resolution URL, giving context the schema alone does not.

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 (verify) plus the exact resource (a signed gspc.measurement-card) and names the governing rule document. It is clearly distinguishable from siblings like verify_capsule and verify_inclusion by naming the artifact it checks.

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 when the tool applies (checking a signed card against a pinned key set) and enumerates the accepted input forms and the resolution behavior for a 64-hex id. It does not, however, explicitly contrast itself with the sibling verifiers or say when not to use it.

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

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

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.