AINumbers Fintech Intelligence Suite

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

Annotations indicate read-only, idempotent, non-destructive. Description reinforces this by stating it returns findings and receipt, no network egress. Adds detail on derivation codes and schema cross-check, exceeding annotation basics.

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 tight sentences front-loading purpose, scope, behavior, and exclusions. Every sentence delivers key information 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?

Description covers all necessary aspects: input, processing, derivation codes, cross-check, output type, and what is excluded. Sufficient for an agent to select and invoke correctly without output schema.

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

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

Single parameter 'credential' is described as ACDC/vLEI JSON object with expected subfields (v, d, i, ri, s, a, e, r). Schema coverage 100%, but description adds meaning about how these fields are processed (SAID recomputation, schema cross-check), which is not in 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 clearly states it recomputes SAIDs of ACDC/vLEI credentials under specific derivation codes and cross-checks schema SAID against a pinned table. It distinguishes this as a structural integrity check separate from trust/authority/revocation tools.

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

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

Explicitly lists what the tool does (structural SAID check) and what it does NOT do (KERI chain of trust, issuer authority, revocation). Mentions reuse of T553 module, giving context for expected behavior.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive), and the description adds genuinely useful context beyond them: transient processing with no storage/logging, the compute:auto vs browser delegation semantics, and the exported AP2 artifact with execution_hash. This is real behavioral disclosure that the 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 opening identifies the resource, but the middle is dense infrastructure boilerplate (kernel registration, browser delegation URL, a 64-char FV-status filename) that is not front-loaded toward the agent's actual decision. It is sized reasonably but much of it does not earn its place for tool selection.

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 4-parameter tool with a nested, opaque policy_parameters object and no output schema, the description leaves the core decision semantics unexplained ('See the tool's manifest for field names') and points to describe_tool for the return shape rather than stating it. An agent cannot determine what inputs the adjudication function needs or what it returns.

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 description's compute-mode text largely duplicates the schema's own enum description verbatim rather than extending it. It adds no meaning for parent_hashes/parent_tool_ids/policy_parameters, and defers policy field names to an external manifest, so the baseline 3 applies.

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

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

The description restates the title ('EMIR Trade-Repository Reconciliation Adjudicator') and then spends nearly all its words on OpenChainGraph infrastructure (compute modes, kernel registration, FV-status receipts). It never says what 'adjudication' actually decides — e.g. which breaks are resolvable — so an agent cannot distinguish this from siblings like reconcile_emir_pairing or age_emir_reconciliation_breaks.

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

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

There is guidance on compute modes and a data-handling constraint ('Use synthetic or anonymised inputs only'), but no statement of when to invoke this tool versus the many EMIR reconciliation siblings. The 'Output feeds: art-483-emir-break-ageing' line hints at chain position but gives no selection criteria.

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

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

Beyond the annotations (readOnly/idempotent/non-destructive), the description adds real behavioral context: deterministic execution, compute:'auto' server-side vs compute:'browser' delegation, transient processing with no storage/logging/retention, synthetic-inputs-only constraint, and AP2 artifact export with execution_hash. This meaningfully lowers the agent's uncertainty about side effects and data handling.

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?

Most of the text is template boilerplate (compute-binding paragraph, FV-status URL, offline-receipt claim) that is not specific to this tool, while the actual ageing semantics are never stated. The domain-relevant content is a small fraction of the whole, so sentences do not each earn their 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?

Operational/execution context (compute modes, provenance, transient processing) is thorough and the output schema is delegated to describe_tool, so return values need not be explained. However, for a 4-parameter compute node with nested policy_parameters, the description never explains what the tool actually computes (ageing buckets, thresholds, output form), leaving a domain gap.

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 repeats the compute-mode semantics already in the schema and defers policy_parameters field names to 'the tool's manifest', adding little beyond what the structured 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 name/title convey a specific verb+resource (ageing EMIR reconciliation breaks), but the description body never restates or expands the domain function; it opens with 'OpenChainGraph compute node (attestation_mandate)' boilerplate. It does name the upstream artifact (art-482-emir-recon-adjudicator), which gives some differentiation from siblings like reconcile_emir_pairing, but the core purpose is only implied.

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

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

There is no when-to-use guidance, no statement of what input is expected (breaks from the adjudicator?), and no comparison against the many EMIR siblings (reconcile_emir_pairing, adjudicate_emir_reconciliation, validate_emir_trade_report). Only 'Consumes upstream artifacts from: art-482...' hints at position in a pipeline.

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 indicate read-only, idempotent, non-destructive behavior, and the description reinforces this by adding valuable context: browser-based, client-side only, zero PII, zero network, and inputs applied via the AIN Bridge. This goes beyond the annotations and clearly sets expectations about side effects and data handling.

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 purpose and includes useful constraints and a pointer to the output schema. It is slightly redundant—'zero PII' and 'client-side' are each stated twice—but the extra repetition is minor and the overall structure is 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 sandbox simulation tool with a generic input map and no output schema, the description covers the key behavioral aspects, the policy dimensions, the client-side environment, and explicitly directs the agent to call describe_tool for the output schema. It is not fully self-contained on exact input element IDs and output field layout, but the pointer compensates substantially.

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% description coverage on the generic 'inputs' map, so the baseline is 3. The description adds value by naming the semantic categories of inputs (spend caps, MCC allowlists, velocity throttles, approval thresholds) and explaining that inputs are applied via AIN Bridge prefill, which helps the agent understand what to populate even without an explicit 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 a specific action ('Simulate agent payment policies'), a concrete domain ('tokenized A2A corridors'), and concrete policy dimensions ('spend caps, MCC allowlists, velocity throttles, approval thresholds'). It also distinguishes the tool by noting the browser-based sandbox behavior and Policy Mandate export, which separates it from vaguely similar siblings like simulate_agent_spend_policy.

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

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

The description gives clear context for when the tool is appropriate: simulating payment policies with synthetic transactions in a tokenized A2A corridor and exporting a Policy Mandate. It does not explicitly name alternatives or state when not to use this tool, but the context is strong enough for an agent to infer the intended use 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?

Annotations already cover safety (readOnly, idempotent, non-destructive), and the description adds meaningful context beyond them: deterministic execution, server-vs-browser compute delegation, transient non-retention of inputs, and export of an AP2 artifact with execution_hash for provenance. These are substantive operational traits not derivable from 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?

It opens with redundant boilerplate ('OpenChainGraph compute node (compliance_mandate). Deterministic OpenChainGraph compute node.'), then piles on URL, FV-status hash, sibling artifact IDs and a describe_tool pointer. Useful facts are present but buried behind infrastructure metadata rather than 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?

For a 4-parameter compute node with no output schema, the description covers execution, provenance and data handling reasonably well, but the decision-function parameters (policy_parameters) remain opaque and no return shape is described beyond 'call describe_tool'. It is adequate but leaves the agent short of what is needed to invoke it confidently.

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

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

Schema description coverage is 100%, so the schema already documents compute, parent_hashes, parent_tool_ids and policy_parameters. The description largely restates the compute-mode semantics and explicitly defers field names to 'the tool's manifest', so it adds a pointer but little else beyond the schema. Baseline 3 applies.

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

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

The description gives a specific verb+resource ('CBAM Precursor-Emissions Aggregator') and tags it as an OpenChainGraph compute node under the compliance_mandate family. However it never distinguishes this aggregator from close siblings such as calculate_cbam_embedded_emissions or resolve_cbam_default_value, so the agent cannot tell when aggregation is the right step versus the calculator.

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 states an input constraint ('Use synthetic or anonymised inputs only') and workflow context (consumes art-68 upstream, feeds art-69 and cry-04), which implies usage. But there is no explicit when-to-use versus the CBAM calculator siblings, so routing guidance 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 cover the safety profile (readOnly, idempotent, non-destructive, closed-world), yet the description adds genuinely new behavior: inputs are processed transiently and not stored/logged/retained, execution is deterministic, and browser mode returns a delegation URL instead of a result. That is meaningful disclosure beyond structured fields, though it never explains what the exported artifact contains beyond execution_hash.

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 opening repeats itself ('OpenChainGraph compute node ... Deterministic OpenChainGraph compute node'), and the URL plus FV-status hash path consume a full sentence with little selection value. The substantive content (compute routing, transient processing, chain provenance) is present and reasonably ordered, but the block is longer than the decision-relevant information warrants.

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

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

For a no-output-schema tool the description does point agents to describe_tool for the output shape and covers chaining, privacy, and compute routing. The critical gap is that the core function remains opaque: policy_parameters is deferred to an external 'manifest', so an agent cannot tell what the aggregation actually computes or what to pass.

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 four parameters (compute, parent_hashes, parent_tool_ids, policy_parameters) are already documented in the schema, including the compute enum semantics. The description largely repeats the compute-mode explanation and adds nothing new for parent_hashes/parent_tool_ids, so baseline 3 applies.

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

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

The title and opening line identify this as an audit-trail aggregator that exports an AP2 artifact carrying execution_hash, which is a concrete verb+resource. It also positions itself in the chain (consumes art-30/art-31/art-33/cry-04, feeds ptg-01), which helps separate it from sibling receipt/validation tools. However, the actual aggregation logic ('decision function', 'policy_parameters') is never described, so an agent knows the output shape but not what is being computed.

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 operational rules (default compute:'auto', compute:'browser' forces delegation, gpu:true always delegates, use synthetic inputs only) but never states when to choose this tool over alternatives such as validate_agent_audit_trail or validate_audit_trail_completeness. Usage is implied through the compute-mode semantics rather than stated as 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 the safety profile (readOnly, idempotent, non-destructive, closed-world), and the description adds genuinely useful behavior beyond them: server vs. browser execution and the browser delegation URL, GPU-node delegation, transient processing with no storage/logging/retention, and emission of an AP2 artifact carrying execution_hash for chain provenance. It does not, however, describe failure modes or what the returned artifact contains structurally.

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 with operational boilerplate — the FV-status receipt hash, the art URL, and a paragraph-length explanation of compute binding that duplicates the schema — while the one thing an agent needs (what the tool computes) is absent. The most decision-relevant content is buried rather than 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?

For a node with opaque policy_parameters and no output schema, the description does supply provenance (upstream/downstream artifacts), privacy handling, and a pointer to describe_tool for the output contract, which partially compensates. It remains incomplete on the core semantics of the 50% rule and on what the AP2 artifact returned actually contains.

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 compute, parent_hashes, parent_tool_ids and policy_parameters are already documented; the description largely repeats the compute-binding semantics the schema states. It adds nothing about the decision-critical policy_parameters object, explicitly deferring to "the tool's manifest," so the baseline 3 holds.

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 text restates the title ("Ownership 50%-Rule Aggregator") and labels it a "compute node (compliance_mandate)" without ever stating what the 50% ownership rule computation actually does, what it decides, or what domain inputs it consumes. Pipeline references (art-90 upstream, art-92/cry-05 downstream) hint at placement but not function, so an agent cannot distinguish it from siblings like compute_cdd_ownership_25pct on capability grounds.

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 only usage direction is a privacy constraint ("Use synthetic or anonymised inputs only") and the compute-mode mechanics. There is no when-to-use/when-not guidance, no prerequisite or input-preparation advice, and no routing to alternative ownership or compliance tools among the many siblings.

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=false, so the bar is lower, and the description adds real value beyond them: deterministic computation, transient processing with no storage/logging/retention, and export of an AP2 artifact with execution_hash for chain provenance. The compute/GPU delegation semantics are also disclosed, though they largely duplicate 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 text is bloated with duplicated framing ('Provable Reputation Score Aggregator: OpenChainGraph compute node (attestation_mandate). Deterministic OpenChainGraph compute node.'), an inline documentation URL, and a long FV-status receipt hash that is noise for tool selection, before the first operationally useful clause.

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

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

For a 4-parameter tool with nested policy_parameters and no output schema, the description never says what the reputation score is computed over or what the response contains beyond 'an AP2 artifact with execution_hash'. The actual aggregation semantics an agent needs are missing.

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

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

Schema description coverage is 100%, so the baseline is 3 and the compute-mode restatement adds nothing not already in the schema. The chaining intent of parent_hashes/parent_tool_ids is only obliquely implied by the 'chain provenance' phrase, and policy_parameters fields are explicitly deferred to an external manifest.

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 by restating the title ('Provable Reputation Score Aggregator: OpenChainGraph compute node') and then spends its budget on infrastructure boilerplate rather than what the tool actually aggregates, from which inputs, or what the resulting reputation score represents. An agent cannot tell from the text why this differs from siblings like aggregate_execution_receipts or score_credit_default_risk beyond the name itself.

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

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

There is no when-to-use vs. when-not guidance and no naming of any alternative tool. The compute-mode paragraph is execution-mechanics guidance, not usage guidance, and 'use synthetic or anonymised inputs only' is a data-safety constraint rather than a selection criterion.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), and the description adds meaningful behavior beyond them: transient processing with no storage/logging/retention, a requirement to use synthetic or anonymised inputs only, server-vs-browser execution semantics, and an exported AP2 artifact carrying execution_hash for chain provenance. That is substantive operational context, though the FV-status receipt aside is largely procedural noise.

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 paragraph is dense with infrastructure boilerplate, repeats the phrase 'OpenChainGraph compute node' twice, and buries the task-relevant sentence (what it aggregates) behind provenance, FV-status, and output-schema instructions. It is over-specified in low-value areas and under-specified on the domain logic.

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

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

There is no output schema, but the description explicitly directs the agent to call describe_tool for the output shape and covers provenance, privacy, and execution mode. What remains thin is the domain side: what policy_parameters must contain and how SCR modules are combined, both deferred to an external manifest.

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

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

Schema description coverage is 100%, so the schema already fully documents compute, parent_hashes, parent_tool_ids, and policy_parameters. The description restates the compute-mode semantics rather than adding syntax or field-level detail, and it explicitly defers policy_parameters field names to the manifest, so it adds little beyond the schema. Baseline 3 applies.

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

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

The title and first line state a specific verb+resource: aggregating Solvency II SCR standard-formula modules into a decision-function output, and it names the downstream artifact (art-180-solvency2-scr-ratio-calculator), which distinguishes it from calculate_solvency2_scr_ratio. However, the actual purpose is embedded inside heavy infrastructure boilerplate rather than front-loaded, so it is clear but not crisp.

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 no explicit when-to-use or when-not-to-use guidance relative to siblings such as calculate_solvency2_scr_ratio, compute_rwa_scenarios, or other Solvency II tools. It describes compute-mode mechanics, which is configuration rather than usage context, leaving the agent to infer applicability from the name.

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

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

Beyond the annotations (readOnly/idempotent/non-destructive), the description adds genuinely useful behavior: the compute:'auto' vs 'server' vs 'browser' execution model, the GPU delegation rule, transient no-storage processing, and the AP2 artifact/execution_hash export for provenance. This is substantive disclosure the annotations do not carry.

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

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

The compute-mode explanation is repeated verbatim from the schema, and the FV-status receipt paragraph is tangential metadata. Front-loaded with the tool identity, but several sentences do not directly help an agent invoke the tool correctly.

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?

A 4-param tool (0 required) with a nested object, no output schema and full annotation coverage. The description covers execution semantics and data handling reasonably well, but never explains what the aggregation actually outputs or the required shape of policy_parameters, leaving the core computation under-specified.

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

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

Schema description coverage is 100%, so the schema already documents compute, parent_hashes, parent_tool_ids and policy_parameters fully. The description re-explains compute mode but adds little on policy_parameters beyond what the schema says, so the baseline 3 applies.

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

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

The title and name indicate a liability aggregation compute node, but the description never states in plain terms what the tool actually computes (e.g., a Merkle-sum-tree liability total). 'OpenChainGraph compute node (cryptographic_mandate)' is opaque jargon rather than a specific verb+resource statement, leaving the actual purpose inferred from the name.

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 does disclose one downstream consumer ('Output feeds: art-620-summa-mst-inclusion-checker') and a data-handling precondition ('Use synthetic or anonymised inputs only'), which implies appropriate use. However there is no explicit when-to-use guidance or comparison against the many sibling aggregation/compute 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?

Annotations already cover safety (readOnly, idempotent, non-destructive), but the description adds genuinely useful behavior: inputs are processed transiently and not stored/logged/retained, the node is deterministic, compute:'browser' returns a delegation URL instead of computing, and it exports an AP2 artifact carrying execution_hash. That is meaningful disclosure beyond the annotations.

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

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

Front-loads the tool's identity well, but the body is padded with boilerplate: a documentation URL, a full FV-status hash path, and a meta-explanation that the receipt 'verifies offline whether or not that file is ever fetched.' That paragraph does not help an agent decide or invoke anything.

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

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

With no output schema but an explicit pointer to describe_tool for it, the description covers chaining, compute binding, data handling, and provenance export. The remaining gap is that policy_parameters is left as 'see the tool's manifest,' so an agent cannot see the actual field names from this description alone.

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 all four parameters are already documented in the schema. The description restates the compute-mode semantics that the schema already gives, and adds only the note that parent_hashes map to chain.parent_hashes in the export. Baseline 3 is appropriate.

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

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

The description leads with the title restated ('Taxonomy KPI & Green Asset Ratio Aggregator: OpenChainGraph compute node'), which is largely tautological, but it does add scope-relevant facts: it names the upstream artifact it consumes (art-73-taxonomy-alignment-scorer) and the downstream consumer (cry-05...), which helps distinguish it from siblings. It never explains what the aggregation actually computes or what shape the policy_parameters input takes.

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

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

There is one real usage constraint ('Use synthetic or anonymised inputs only') and chaining context (parent_hashes from upstream AP2 artifacts), which implies how it fits into a chain. However there is no explicit when-to-use/when-not statement or named alternative among the many sibling aggregate_*/compute_* 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?

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), but the description adds genuinely new behavior: transient processing with no storage/logging/retention, server vs browser delegation semantics including gpu:true always delegating, and export of an AP2 artifact carrying execution_hash for chain provenance. This is well beyond what the structured fields 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 purpose is front-loaded, but the body is a dense run-on of boilerplate including a full FV-status hash and a raw URL. Several clauses earn their place (compute modes, data handling), yet the receipt/URL material is filler that bloats the definition.

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

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

With no output schema, the description helpfully points to describe_tool for the output shape, and it covers compute mode, data-retention posture, provenance export, and upstream chaining dependencies. For a compute node with a nested policy_parameters object, this is close to complete, though the actual computation is never characterized.

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 four documented parameters, so the schema already carries the parameter semantics. The description only restates compute-mode behavior (which the schema documents) and defers policy_parameters field names to the manifest, adding little 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 identifies the tool as an 'IHB Interest Allocation' OpenChainGraph compute node in the 'analytics_mandate' family, which gives a verb+resource frame. However, it never explains what the allocation computes or what 'IHB' refers to, so an agent cannot distinguish the actual operation from sibling compute nodes without opening the manifest. The classification label largely restates the name.

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 context is implied by the upstream artifact list (art-259-compute-multilateral-netting, art-262-validate-ebam-acmt-flow), suggesting this tool runs downstream in a chain, and it mandates synthetic/anonymised inputs. There is no explicit statement of when to choose this tool over alternatives or any exclusions.

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

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

Annotations already declare readOnly/idempotent/non-destructive, so the bar is lower, and the description adds genuine behavior: inputs are processed transiently and not stored or logged, a browser delegation URL is returned for compute:'browser'/gpu:true, and an AP2 artifact with execution_hash is exported for provenance. These are real traits beyond the annotations.

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

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

The purpose is front-loaded, but the body is padded with generic OpenChainGraph scaffolding, a full FV-status URL and 64-char hash, and repeated compute-mode text that duplicates the schema, all before any task-specific guidance. Much of the length does not earn 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 4-param compliance compute node with no output schema, the description covers storage, compute modes, provenance, and upstream chaining, and defers output structure to describe_tool. The significant remaining gap is the policy_parameters object, whose field names are deferred to an external manifest, leaving core input semantics unstated.

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

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

Schema description coverage is 100%, so the schema already documents compute, parent_hashes, parent_tool_ids, and policy_parameters. The description's compute-mode explanation largely restates the schema, and it adds little on parent_hashes ordering or the opaque policy_parameters object. Baseline 3 applies.

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

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

The opening states a specific verb+resource: amortization of ASC 340-40 commissions, and the title confirms the domain. However, it never distinguishes itself from near-siblings like build_amortization_schedule, compute_deterministic_amortization_schedule, or reconcile_commission_statement, so a sibling-differentiation gap remains.

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 an input constraint ('Use synthetic or anonymised inputs only') and names the upstream artifact (art-266-reconcile-commission-statement), which implies context. But it never states when to prefer this tool over the other commission/amortization siblings, so usage is only implied.

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

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

On top of the annotations (readOnly/idempotent/non-destructive), the description discloses real behavior: default server-side execution on Cloudflare Workers, compute:"browser" returning a delegation URL, transient processing with no storage or logging, and export of an AP2 artifact carrying execution_hash. That is meaningful operational context beyond the annotation set.

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 text is dominated by infrastructure boilerplate, a URL, and a full FV-status receipt hash, while the substantive purpose and output are never stated. The subject is buried behind compute-binding and provenance machinery rather than 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?

This is a nested-input, no-output-schema tool, so the description should clarify what the cost-benefit decision function consumes and returns. Instead it defers field names to 'the tool's manifest' and never describes the analytical result, leaving the core substance undocumented.

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

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

Schema description coverage is 100%, so the schema already documents compute, parent_hashes, parent_tool_ids, and policy_parameters. The description only paraphrases the compute-mode semantics already in the schema and adds nothing about the decision-function fields inside policy_parameters, landing at 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 opening sentence restates the title ('Documentary Collection vs Letter of Credit Cost-Benefit') and tags it as an OpenChainGraph compute node in the compliance_mandate category. An agent can infer the subject is a DC-vs-LC cost comparison, but nothing explains what the analysis computes or how it differs from siblings like compute_ltc_funding_comparator or compare_receivables_finance_economics.

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

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

There is no when-to-use or when-not-to-use guidance and no routing to any of the many related trade-finance siblings. The only advisory text ('Use synthetic or anonymised inputs only') is a data-handling constraint, not tool-selection 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 the safety profile (readOnly, idempotent, non-destructive), so the bar is lower. The description adds genuinely useful context: transient processing with no storage/logging, a requirement to use synthetic or anonymised inputs, server-vs-browser execution semantics, and an AP2 artifact with execution_hash for provenance. It still omits rate limits, error modes, and what the artifact contains, so it is above-neutral but not rich.

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

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

Purpose is buried under infrastructure boilerplate, internal URLs, an FV-status hash, and a pointer to the sibling tool describe_tool. Multiple sentences repeat the same OpenChainGraph/compute-node framing, and the opening verb+resource statement never appears at all, so the text is neither front-loaded nor waste-free.

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 4-parameter, nested-object tool with no output schema, the description should convey what an agent gets back and how to supply policy_parameters. Instead it documents hosting and provenance, defers the output contract to describe_tool, and leaves the core input semantics to 'the manifest'.

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

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

Schema description coverage is 100%, so the schema already documents compute, parent_hashes, parent_tool_ids, and the generic policy_parameters bag. The description adds only routing context for compute and says nothing about what fields policy_parameters should contain ('see the manifest'), so it does not meaningfully exceed the schema baseline.

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

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

The description identifies this as an OpenChainGraph compute node for 'event_market_pnl', implying a prediction-market P&L / analysis function, but never states in plain language what the tool computes or returns. It is a bundle of infrastructure, routing, and provenance notes rather than a purpose statement, so an agent must infer the actual function from the slug 'event_market_pnl'.

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

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

There is detailed guidance on compute routing ('auto' vs 'server' vs 'browser'), but nothing about when this analysis tool should be selected over the very numerous sibling analyzers/calculators. It never states the user situations or question types that should route here, so an agent has no selection criteria.

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, but the description adds real behavioral substance beyond them: transient processing with no storage/logging/retention, the synthetic-input requirement, server-vs-browser delegation semantics, and the AP2 artifact with execution_hash for chain provenance. This is solid added context, though it does not cover latency, limits, or failure modes.

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 text is a dense wall that repeats the title, buries the actual purpose under compute-mode detail, and includes low-signal filler such as the FV-status hash and the 'snapshot, not a subscription' receipt caveat. Genuinely useful facts (transient processing, output artifact, downstream verifier) are scattered rather than 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?

For a complex compute-node tool with a nested policy_parameters object and no output schema, it does cover execution behavior well and points the agent to describe_tool for the return shape. What is missing is the core semantic: what decision/artifact this node actually produces from a document, which is left largely to inference.

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

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

Schema description coverage is 100%, so the schema already documents compute, parent_hashes, parent_tool_ids, and policy_parameters thoroughly. The description restates the compute:auto/browser behavior that the schema already spells out and adds only that policy_parameters are computed server-side for kernel-registered nodes, giving little beyond the baseline.

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

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

The title and first line identify a specific verb+resource (anchoring document integrity with an eIDAS timestamp) and the artifact it exports (AP2 artifact with execution_hash). However, the body spends most of its words on compute plumbing rather than stating concretely what the anchor operation computes on a document, and it never distinguishes itself from the closely-named sibling anchor_stamp. An agent gets the gist but not a crisp operational definition.

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 supplies workflow context (output feeds art-122-timestamp-attestation-verifier) and a data constraint ('synthetic or anonymised inputs only'), but gives no when-to-use/when-not guidance and no routing against alternatives like anchor_stamp or verify_timestamp_attestation. The compute-mode discussion is invocation mechanics, not usage 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 claim no read-only, no idempotency, no destructiveness. The description elaborates meaningfully: success is only reported after independent confirmation of hash equality, failures return {ok:false, unanchored:true, reason} verbatim, never fabricating bindings, and the authority default is delegated/mirrored from anchor-suite. This is deep and valuable behavior disclosure beyond 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?

Well organized with clear cause-effect chains, but somewhat long — the failure-mode sentence and trust rationale could be tightened. Front-loads the core action first, which is good. No wasted 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?

Complex tool (real-time authority, batch anchoring, cryptographic verification, OCG shaping) with no output schema, yet the description fully explains the success/failure contract, the verification guarantee, the batch mechanics, and the calling context. An agent can predict exactly what happens in every path.

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

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

Schema coverage is 100%, so baseline is 3. The description adds meaningful semantics for execution_hash (single vs 2+ batch array, RFC 6962 Merkle root, per-hash merkle_inclusion) and authority (mirrors anchor-suite default). Only minor gap: array items lack 'sha256:' prefix documentation but this is minor.

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 clear, specific action: timestamping execution_hash(es) via anchor-suite at a real timestamp authority, shaping results as OCG v0.7 section 20 anchor_bindings. Distinguishes from siblings (e.g., verify_execution_hash, verify_timestamp_attestation) by noting server-to-server vs browser relay and the explicit OCG shaping.

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 this is called (caller-invoked only, not wired into automatic emission), the batch vs single path, and its trust posture. Lacks explicit when-not/alternative tool naming, but the caller-invoked note and clear scope give sufficient context.

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 signal read-only, idempotent, and non-destructive; the description adds behavioral context beyond annotations: 'Browser-based, client-side only', 'Zero PII', 'zero network', and 'inputs are applied via the AIN Bridge'. It also tells the agent where to get the output schema. 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 short but has repetitive claims ('client-side'/'zero PII' repeated, 'zero network' added only in the last sentence) and the truncation 'agentic payment sy Browser-based' hurts readability. It could be tightened into two clean sentences without losing information.

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

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

Annotations cover safety and the schema covers the input envelope; the main missing piece is what the Policy Mandate JSON contains, and the description points to `describe_tool('ap2_aml_mandate_builder')` for that, which is helpful. However, undefined terms like 'Cat-12', 'TM rules', and 'AIN Bridge' plus the lack of concrete input IDs leave an agent dependent on external manifests or a describe call before invoking.

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 only parameter has a schema description ('Map of tool input element IDs to values (see manifest input_schema)'), and coverage is 100%, so baseline 3 applies. The tool description reinforces that inputs are applied via the AIN Bridge but does not list the element IDs or value shapes an agent would actually need; it refers to the manifest 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?

States a concrete transformation: 'Translate AML/BSA program controls, TM rules, and customer risk policy into a structured Policy Mandate JSON.' The resource and output are identifiable, so an agent can tell it is a mandate-building tool even without opening schema. It doesn't explicitly distinguish from mandate-related siblings such as build_ap2_cartmandate_hashchain or validate_ap2_mandate_chain, and the phrase 'agentic payment sy' is truncated, so not a 5.

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?

Some context is present ('Anchor agentic tool for Cat-12', 'for interactive use'), and the note about linking users to the interactive URL implies a browser-widget use case. However, the description never states when to choose this tool over sibling builders/validators, nor any exclusion criteria, leaving timing to inference.

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

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

Annotations already declare read-only, idempotent, non-destructive, closed-world, and the description adds genuinely new context: determinism, transient processing with no storage/logging/retention, AP2 artifact export with execution_hash for chain provenance, browser delegation behaviour, and a snapshot-only FV receipt. It is strong on the privacy and provenance profile, though it omits error/rate-limit behaviour.

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

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

It is front-loaded with the tool name and node classification, but then runs into a dense, punctuation-heavy block mixing compute routing, privacy, provenance, upstream/downstream IDs, a URL, and an FV-status receipt hash with no structural separation. Several clauses repeat schema content, and the FV-status sentence is verbose boilerplate.

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 no output schema (deferred via describe_tool) and a nested policy_parameters object, the description covers provenance, privacy, and compute routing well. What it never supplies is the substance of the computation — the policy_parameters field names that an agent must populate — so the definition is workable but not sufficient on its own.

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 compute, parent_hashes, parent_tool_ids are fully documented in the schema. The description adds nothing beyond echoing the compute modes and explicitly punts on policy_parameters ('See the tool's manifest for field names'), so the baseline 3 is correct.

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 title and first line establish the domain (NGFS / Fit-for-55 climate scenario, model_governance compute node), but the actual operation is never described — the opening sentence largely restates the title, and the real work ('policy_parameters ... See the tool's manifest for field names') is deferred. Against siblings like run_carbon_compliance_fit or compute_stress_test_scenarios the boundary is only implied, not stated.

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

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

It gives operational guidance for the compute mode (auto/server/browser, gpu:true always delegates) and a real constraint ('Use synthetic or anonymised inputs only'), plus upstream/downstream artifact wiring. However it never says when to choose this tool over the adjacent carbon/stress-scenario siblings, leaving selection to inference.

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

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

Annotations already declare readOnlyHint/idempotentHint/destructiveHint=false, so the safety profile is covered; the description goes further by disclosing transient processing (not stored, logged, or retained), the synthetic-input requirement, deterministic execution_hash provenance, and the browser-delegation behavior. That is meaningful added context beyond the annotations, though the export side effect is not explicitly reconciled with readOnlyHint.

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

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

Front-loads the identity and compute behavior well, but the tail is bloated with an FV-status hash and the self-referential "a snapshot, not a subscription; this receipt verifies offline..." clause that does not help an agent invoke the tool. The mix of pipeline metadata, provenance boilerplate, and a link dilutes the actionable content.

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

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

With no output schema, the description carries the return burden and does so reasonably: it names the AP2 artifact and execution_hash and points to describe_tool for the full output schema. For a zero-required-parameter compute node with chaining inputs, the data-handling, compute-mode, and chain-position facts cover what an agent needs to call it correctly.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters, and the description largely restates the compute semantics rather than extending them. It only indirectly gestures at parent_hashes/parent_tool_ids through the "consumes upstream artifacts" chain note, and defers policy_parameters to "the tool's manifest".

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

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

States a specific verb+resource ("AI Addendum Assembler", a compliance_mandate compute node) and anchors it in a pipeline by naming the exact upstream artifact it consumes and the downstream artifact it feeds. The only weakness is that "AI addendum" is left as jargon – it never says plainly that it assembles an AI Act procurement addendum artifact – but an agent can still distinguish it from siblings via the artifact IDs.

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 real routing guidance for the compute mode ("auto" server-side for gpu:false kernels, "browser" for delegation, gpu:true always delegates) and a usage constraint ("Use synthetic or anonymised inputs only"). However it never says when to choose this tool over adjacent siblings such as assemble_aiuc1_evidence_pack or build_ai_conformity_pack, so pipeline position is only implied.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), so the bar is lower, and the description adds real context beyond them: deterministic server-side compute on Cloudflare Workers, browser delegation semantics, transient input processing with no storage or logging, a synthetic-inputs-only restriction, and an AP2 artifact carrying execution_hash. The remaining text (FV-status receipt path, URL) is provenance boilerplate rather than behavioural disclosure.

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

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

The definition is bloated with cross-cutting infrastructure boilerplate (Worker execution model, compute binding, FV-status sha256 receipt path) that appears generic to every node in this family and crowds out tool-specific content. The purpose is front-loaded, but the compute-binding and provenance paragraphs repeat material already carried by the schema and annotations.

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 compute node with no output schema, the description does cover the essentials: it names the chain inputs and downstream consumer, discloses where the output goes and that it carries execution_hash, and explicitly routes the agent to describe_tool for the output schema. The gap is policy_parameters, whose semantics are pushed to an external manifest rather than resolved here.

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 all four parameters are documented in the schema, including the compute enum and the parent_hashes/parent_tool_ids ordering rule, so the baseline of 3 applies. The description duplicates the compute-mode explanation rather than extending it, and it adds nothing about policy_parameters beyond deferring to 'the tool's manifest' — the schema's own wording.

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 gives a specific verb+resource (assembles an AIUC-1 evidence pack, exporting an AP2 artifact with execution_hash) and situates it in a named pipeline between art-303-aiuc1-control-evidence-linter and art-305-aiuc1-evidence-freshness-lint, which separates it from the generic assemble_ocg_evidence_bundle sibling. However, the opening line is largely a title restatement plus an internal jargon tag ('OpenChainGraph compute node (compliance_mandate)'), and what the assembled pack actually contains is never stated.

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

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

Usage is implied through chain position — upstream artifacts are named explicitly and the downstream consumer is named — so an agent can infer this is the middle step of a defined AIUC-1 flow. There is no explicit statement of when to choose this over assemble_ocg_evidence_bundle, build_evidence_pack, or build_226j_response_evidence_pack, and no stated prerequisites for the upstream artifacts.

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/idempotentHint/no-destructive, so the safety profile is covered; the description adds genuinely useful behavior: compute:auto vs browser execution, that gpu:true always delegates, that inputs are processed transiently and not stored/logged/retained, the synthetic-input requirement, and the AP2 execution_hash export for chain provenance. It does not contradict annotations and the transient-processing/no-retention disclosure is exactly the kind of extra context this dimension rewards.

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 long and repeats boilerplate ('OpenChainGraph compute node' appears twice) before ever stating the tool's actual function, so it is not ideally front-loaded. Much of the content (compute binding, provenance, FV-status receipt) is relevant, but the redundant opening and the verbose FV-status hash sentence dilute it.

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 4-param, nested-object, no-output-schema compute node, the description covers execution modes, data handling, pipeline position and explicitly points to describe_tool for the output shape, which is reasonable. However, the actual decision-function semantics of license-term assembly and the policy_parameters field names remain unexplained, leaving a substantive gap for the core computation.

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

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

Schema description coverage is 100%, so the schema already documents compute, parent_hashes, parent_tool_ids and policy_parameters, and the description's compute-mode text overlaps what the schema says. Baseline 3 is appropriate; the description adds little beyond the chaining/provenance framing and defers policy_parameters field names to an external manifest.

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 largely restates the name/title ('License Terms Assembler: OpenChainGraph compute node'), and never explains what assembling license terms actually computes. It does add pipeline positioning (consumes art-204-license-compatibility-checker, feeds art-206-rights-record-builder), but that is provenance scaffolding rather than a statement of what the tool does, and it does not clearly differentiate from siblings like check_license_compatibility or certify_license_election.

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

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

There is no explicit when-to-use/when-not guidance and no named alternative. The only usage signal is the implied pipeline position from the upstream/downstream artifact IDs, which requires the agent to already understand the ChainGraph ordering to act on 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 establish readOnly/idempotent/non-destructive/closed-world, so the bar is lower, and the description still adds real value: transient processing with no storage, logging or retention, the AP2 artifact plus execution_hash for chain provenance, and the browser-delegation fallback for gpu:true nodes. These are behavioral facts an agent cannot infer from the annotations or schema. It stops short of describing the export/artifact payload itself.

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 one dense block mixing compute mechanics, an external URL, and a long FV-status hash that consumes significant space without helping selection or invocation. The core purpose appears first but is immediately buried under infrastructure jargon and a snapshot-verification aside that does not earn its length.

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

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

For a zero-required-parameter compute node with a nested policy_parameters object and no output schema, the description covers execution semantics and provenance adequately, and explicitly points agents to describe_tool for the output schema. However, the actual NDA decision inputs are deferred to an out-of-band manifest, so an agent still cannot call this tool confidently from the definition alone.

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 on compute is fully documented in-schema, so the schema carries the load. The description restates the auto/server/browser semantics but adds no field-name detail for policy_parameters, instead deferring to an external manifest ('See the tool's manifest for field names'), which leaves the most consequential input effectively undocumented in-band.

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 title and name identify the resource (a mutual NDA) and the family (OpenChainGraph compute node, compliance_mandate), so an agent can tell roughly what it produces. But the description spends most of its text on compute-mode plumbing rather than stating a specific verb+outcome (e.g., 'drafts a mutual NDA from supplied party/term fields'). It also never distinguishes itself from sibling assemblers such as assemble_license_terms or assemble_ai_addendum.

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

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

There is one genuine usage constraint ('Use synthetic or anonymised inputs only'), which is useful. Otherwise there are no when-to-use / when-not-to-use cues relative to the many sibling assemble_*/compose_* tools, and the compute-mode sentences read as parameter behavior rather than invocation guidance.

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

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

Annotations already declare readOnly/idempotent/non-destructive, but the description adds genuine behavioral context beyond them: inputs are processed transiently and not stored/logged/retained, gpu:true nodes always delegate to the browser, browser mode returns a delegation URL, and the call exports an AP2 artifact with execution_hash. That is meaningful execution and data-handling detail the agent would not otherwise know.

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-loading is reasonable and the compute/privacy sentences earn their place, but the long FV-status receipt URL with its 'snapshot, not a subscription' aside and the describe_tool pointer add bulk without helping selection or invocation. The text reads as a manifest dump rather than a tight definition.

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 compute node with nested policy_parameters and no output schema, the description never explains the domain purpose, what 'tiers' are produced, or what the returned AP2 artifact contains beyond a bare execution_hash, deferring output shape to describe_tool. Operational behavior is well covered, but the essential 'what does this produce' gap leaves the definition inadequate.

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

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

Schema description coverage is 100%, so the schema already documents compute (with the same enum semantics), parent_hashes, parent_tool_ids, and policy_parameters. The description largely repeats the compute-mode meaning rather than adding new parameter detail, so it lands at the baseline 3 with little extra value.

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

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

The description mostly restates the title ('Evidence Bundle Tier Labeler') and labels it an 'OpenChainGraph compute node (attestation_mandate)' and 'Deterministic OpenChainGraph compute node' without stating what the tool actually computes or what a 'tier label' is. It never gives a plain verb+resource for the domain operation, so an agent cannot distinguish it from the many other assemble_*/build_*/attest_* siblings beyond its category tag.

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?

No explicit when-to-use/when-not or alternative-tool guidance is given; the closest thing is the compute-mode discussion, which explains execution routing rather than when this tool should be chosen. The privacy note ('use synthetic or anonymised inputs only') is a constraint, not usage guidance, and no sibling like build_evidence_pack or assemble_aiuc1_evidence_pack is referenced.

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 it read-only, idempotent and non-destructive, so the safety profile is covered. The description adds substantial value beyond that: transient/non-retained input handling, deterministic compute, server-side vs browser delegation behavior, gpu:true always delegating, and the AP2 artifact/execution_hash export with an upstream artifact dependency. This is genuinely useful operational 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?

The compute/provenance facts are front-loaded, but the description is long and repeats the resource name from the tool name and title, and the trailing FV-status receipt/URL paragraph is verbose and tangential. It is not padded with empty prose, yet several sentences could be trimmed without losing instruction 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 compute-node tool with no output schema, the description covers the compute path, data handling, upstream artifact consumption, and the exported AP2 artifact with execution_hash, which is enough to invoke it correctly. It stops short of describing what a readiness verdict looks like, but annotations and the schema cover the remaining mechanical needs.

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 all four parameters are already documented, and the description merely restates the compute-mode semantics. The ambiguous policy_parameters object is glossed with "See the tool's manifest for field names", which adds nothing beyond the schema's own hedge. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The title/spec name gives a specific verb+resource (assess readiness to publish an agent directory), but the description body is dominated by compute-node and provenance boilerplate rather than stating what the readiness decision actually evaluates. It does not distinguish itself from near-neighbors such as run_mcp_deployability_diagnostic or score_mcp_readiness, so an agent can only guess which diagnostic applies.

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

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

There is real guidance on the compute mode ("auto" vs "server" vs "browser") and a data-hygiene instruction ("Use synthetic or anonymised inputs only"), which is useful. However, there is no when-to-use-this-vs-alternatives guidance, no prerequisites, and no indication of when to prefer a sibling readiness 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 cover the safety profile (readOnly, idempotent, non-destructive, closed-world), and the description adds materially beyond them: deterministic server-side vs browser delegation behaviour, the transient/not-stored/not-logged data-handling guarantee, and the AP2 artifact with execution_hash. These are genuine behavioural traits an agent needs and could not infer from the annotations or 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 a dense run-on that front-loads the title but then buries the reader in regulatory amendment history (Digital Omnibus, Parliament approval June 2026) and a verbatim FV-status hash URL plus an explanation of why it is a snapshot. Much of this does not help an agent decide whether or how to call the tool, so several sentences fail to earn their 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 no output schema, the description carries the burden of explaining returns, and it only partially does so (mentions an AP2 artifact with execution_hash and lists downstream consumers). It never describes what a conformity assessment result contains, which leaves a gap for such a complex regulatory tool, though inputs, modes, and data handling are adequately covered.

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

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

Schema description coverage is 100%, so all four parameters are already documented, and the description's compute-mode sentence largely repeats the 'compute' schema description (adding only that 'browser' returns a delegation URL). For policy_parameters it defers entirely to 'the tool's manifest for field names', adding no semantic detail. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The name and title identify a conformity assessment for EU AI Act credit-scoring (Annex III Part 5(b)), and the description anchors the regulatory basis and deadline. However, it never states in plain terms what the tool actually computes or returns — it leads with infrastructure detail (compute binding, FV-status receipts) rather than a verb+resource statement of the assessment. It also fails to distinguish itself from close siblings like run_ai_act_highrisk_fit or classify_annex3_decisioning_obligations.

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 credit-scoring high-risk context and the '2027-12-02' deadline signal when the tool is relevant, and 'Use synthetic or anonymised inputs only' is a real constraint. But there is no explicit when-to-use versus alternatives, no exclusions, and no sibling routing (run_ai_act_highrisk_fit, assess_iso42001_aims_conformance) despite many near-neighbours in the catalogue.

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/closed-world, and the description adds genuinely new behavior: compute-mode routing (auto/server/browser, gpu:true delegation), transient processing with no storage or logging, and export of an AP2 artifact carrying execution_hash for provenance. That retention and provenance detail goes beyond what the annotations carry.

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

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

The text opens by restating name and title, then dumps metadata that doesn't help invocation: a documentation URL, an FV-status SHA-256 hash, and a note that the receipt is 'a snapshot, not a subscription'. Key operational facts are buried mid-paragraph after the metadata noise, so the definition is neither front-loaded nor lean.

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

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

For a tool whose core input is an open-ended policy_parameters object, the description defers field discovery to 'the tool's manifest' and the return shape to describe_tool(...), leaving the decision function opaque. It does cover the compute modes, provenance export, and input-handling policy, but the central question — what gets assessed and with which fields — is outsourced.

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

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

Schema description coverage is 100%, so the schema already documents compute, parent_hashes, parent_tool_ids, and policy_parameters. The description's compute-mode sentence is largely a restatement of the schema's own compute description, adding no extra syntax or semantics. Baseline 3 applies when the schema does the heavy lifting.

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

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

It labels itself an 'OpenChainGraph compute node (compliance_mandate)' and names a resource ('circumvention diligence'), but never states what the assessment actually decides or returns — 'assess' is the only verb and its subject is left abstract. The chaining lineage (consumes art-94, feeds art-96/cry-04) hints at scope but doesn't tell an agent what the tool computes.

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

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

There is no when-to-use or when-not-to-use guidance, and no named alternative among the many sibling assess_* tools. The only prescriptive line, 'Use synthetic or anonymised inputs only', is a privacy constraint, not selection guidance. Upstream/downstream artifact IDs describe chaining, not when this tool is the right pick.

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

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

Beyond the readOnly/idempotent/non-destructive annotations, the description discloses genuinely useful behavior: deterministic server-side compute for gpu:false nodes, browser delegation URLs for gpu:true, transient non-stored input processing, and an exported AP2 artifact carrying execution_hash. It doesn't clarify what the readiness verdict itself contains, but the operational profile is well covered.

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

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

Long and poorly front-loaded: the opening sentence repeats the title, then a wall of platform boilerplate (compute binding, FV-status receipt URL, hosting notes) precedes any substantive information. Much of it does not earn its place for selecting or invoking this specific tool.

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

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

There is no output schema, and the description partially compensates by naming the exported AP2 artifact and pointing to describe_tool for the output shape. But the free-form policy_parameters object — the actual decision inputs — is left unexplained, which is a notable gap for a 4-parameter nested-input tool.

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

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

Schema description coverage is 100%, so compute, parent_hashes, parent_tool_ids and policy_parameters are already documented in the schema. The description echoes the compute-mode semantics and the upstream chaining intent, but adds no field-level meaning beyond that, notably leaving policy_parameters field names to 'the tool's manifest'.

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 name/title states a verb+resource (assess CRA Art. 14 vulnerability reporting readiness), and the pointer to an upstream artifact from art-139-cra-annex1-completeness-checker gives some sibling differentiation. However, the body never explains what the assessment actually evaluates or produces; it is dominated by OpenChainGraph compute-binding boilerplate rather than 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?

No when-to-use guidance relative to siblings such as check_cra_annex1_completeness or run_dora_readiness_diagnostic. The only 'guidance' concerns compute mode selection (auto/server/browser), which is an execution mechanic, not a routing condition.

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

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

Annotations already declare readOnly/idempotent/non-destructive, so the safety profile is covered. The description does add real operational context beyond that — transient processing with no retention, server vs. browser compute delegation, GPU always delegating, and emission of an AP2 artifact with execution_hash. However, none of it describes the tool's actual analytical behavior or output, so it adds infrastructure transparency, not tool-specific transparency.

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 text is dominated by templated compute-node boilerplate, a raw FV-status SHA-256 URL, and offline-receipt language that consumes most of the length without helping an agent invoke the tool. The only tool-identifying content is the opening title clause, so the signal-to-noise ratio is poor despite a front-loaded first sentence.

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

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

No output schema exists, and the description punts returns to 'call describe_tool("assess_defi_lending")' while policy_parameters field names are deferred to 'the tool's manifest' — leaving the core analytical inputs and outputs entirely unspecified. For a nested-object analytics tool with zero required params, this is a significant completeness gap.

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 all four parameters (compute, parent_hashes, parent_tool_ids, policy_parameters) are documented in the schema with enums described. The description's restatement of compute:"auto"/"browser" and the AP2 chaining of parent hashes mirrors the schema rather than adding syntax or format detail, so the baseline of 3 is appropriate.

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

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

The title names a domain (DeFi lending health/liquidation), but the description body never states what the tool actually computes — position health factors, liquidation thresholds, or risk metrics. Everything past the first clause is generic compute-node boilerplate that would apply to any node in this family, so it doesn't distinguish this tool from siblings like compute_ltv_ratios or assess_restaking_risk.

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

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

There is no when-to-use guidance and no named alternative. The only constraint offered is 'Use synthetic or anonymised inputs only,' which is an input-policy warning, not usage routing. An agent cannot tell from this text when a DeFi lending assessment is the right call versus another risk 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/idempotent/non-destructive/non-open-world, but the description meaningfully adds that inputs are processed transiently and 'not stored, logged, or retained', that compute:'browser' returns a delegation URL, and that an AP2 artifact with execution_hash is exported. That is genuine behavioral context beyond structured fields, though it stops short of describing response shape or failure modes.

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 text is a dense run-on mixing purpose, compute plumbing, privacy policy, artifact export, a URL, and an FV-status receipt with a full hex hash. The one agent-relevant selector cue (what the tool does) is buried behind infrastructure boilerplate, and the receipt/URL sentences do not help selection or invocation.

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

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

With no output schema and nested, opaque policy_parameters, the description offloads field names to 'the tool's manifest' and the return schema to describe_tool('assess_exam_readiness_pack'). That pointers are useful, but an agent still lacks the semantic content of policy_parameters or what the readiness output contains, leaving a moderate gap for a 4-param nested compute node.

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

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

Schema description coverage is 100%, so the schema already documents compute, parent_hashes, parent_tool_ids, and policy_parameters in detail. The description's explanation of compute:'auto'/'browser' and gpu:true delegation largely duplicates the schema, adding no syntax or format detail. Baseline 3 for a fully-covered 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 leads with 'Examination Readiness Pack: OpenChainGraph compute node (compliance_control)' and 'Deterministic OpenChainGraph compute node' – essentially a restatement of the title plus infrastructure labels. It never says what an exam-readiness assessment actually evaluates, what decision it makes, or how it differs from the many sibling 'assess_*' tools. The core purpose is left as a tautology.

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 only guidance is 'Use synthetic or anonymised inputs only', which is a data-handling constraint, not a when-to-use rule. There is no statement of when this readiness pack applies versus alternatives like assess_psd3_readiness or run_t1_readiness_diagnostic, and no prerequisites or exclusions.

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

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

Annotations already declare readOnly/idempotent/non-destructive, and the description adds substantial context beyond them: server-side execution on Cloudflare Workers, browser-delegation fallback, transient non-retained processing, and an AP2 export carrying execution_hash plus an offline-verifiable FV receipt. It stops short of describing the assessment's logic or failure modes, but this is rich for an annotated read-only node.

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 prose is a dense run-on that buries the point, and it embeds a full 64-character FV hash and a bare URL inline, which is clutter rather than signal. Compute mechanics are front-loaded ahead of any statement of what the tool evaluates.

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-required-param, no-output-schema node, the safety and execution-mode context is reasonably covered, but the description defers return detail to describe_tool and never explains the assessment semantics or what a conformance verdict contains. Adequate but with clear gaps.

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 compute/parent_hashes/parent_tool_ids/policy_parameters are already documented. The description mirrors the compute-mode explanation already in the schema and adds only the chaining intent ('output feeds art-172'), which is marginal beyond structured data — baseline 3 applies.

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

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

The name and title convey that this assesses ISO 42001 AIMS clause conformance, and the description identifies it as a 'compliance_mandate compute node' whose output feeds art-172. But the body is dominated by compute-plumbing jargon and never says what the assessment actually evaluates or what the caller supplies to drive it, so a sibling like check_gpai_code_conformance is not clearly differentiated.

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

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

There is no explicit when-to-use guidance, no exclusions, and no named alternative among the many conformance tools. The only usage-like statement is the safety constraint 'Use synthetic or anonymised inputs only,' which is a restriction rather than 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 declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so safety is covered. The description adds genuinely useful behavior the annotations do not: the compute:'auto'/'server'/'browser' resolution logic, gpu:true always delegating to the browser, transient processing with no storage/logging/retention, and the AP2 artifact with execution_hash for chain provenance. However, much of the compute-mode text is duplicated from the schema, so the net gain over structured fields is moderate.

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 opening title/domain phrase is front-loaded, and the description does pack the important caveats (transient processing, synthetic inputs) into a compact block. However, it wastes space on platform boilerplate — the full FV-status hash, the artifact URL, and the 'call describe_tool(...)' pointer — that an agent selecting a tool gains little from. Leaning towards efficient but padded.

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

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

No output schema exists, and the description deflects by telling the agent to call describe_tool for it, which is not a substitute. The critical input — what field names policy_parameters requires for the MAR assessment — is explicitly unavailable ('See the tool's manifest'), so an agent cannot construct a valid assessment call from this definition alone. The chain-provenance fields are covered, but the functional core is not.

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 compute, parent_hashes, parent_tool_ids and policy_parameters are all documented in the schema itself; baseline 3 applies. The description adds nothing beyond that — notably it defers policy_parameters field names to 'the tool's manifest', so it does not compensate for the opaque, schema-undocumented contents of that object.

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 restates the title verbatim ('MAR-Crypto Surveillance-Readiness Assessor') and tags the node type as 'compliance_mandate', but never states in its own words what the tool actually assesses or produces. There is no verb+resource statement (e.g. 'scores a firm's MAR Article 12 surveillance controls against crypto-specific criteria'), and no differentiation from the many sibling readiness assessors (assess_mica_casp_readiness, run_mica_casp_fit, assess_agent_directory_publish_readiness).

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 only actionable usage instruction is 'Use synthetic or anonymised inputs only', which is a privacy caveat rather than when-to-use guidance. The upstream/downstream chain references (art-98-mica-casp-fit-diagnostic, cry-05-agent-action-audit-trail-aggregator) hint at pipeline position but do not tell the agent when to pick this tool over sibling readiness diagnostics. No exclusions or alternative-selection criteria are given.

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

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

With annotations already covering readOnly/idempotent/non-destructive, the description still adds real value: inputs are 'processed transiently... not stored, logged, or retained', inputs should be 'synthetic or anonymised', execution is deterministic, and it exports an AP2 artifact with execution_hash for provenance. The 'Use synthetic or anonymised inputs only' warning is an important behavioral constraint beyond the annotations.

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

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

The text is a dense run-on combining title, compute-binding boilerplate, data-retention policy, artifact chaining, an HTML URL, and a sha256 FV-status file path. Front-loading is poor (title restated first, actual purpose never surfaced), and the URL/hash-receipt sentences consume space without helping an agent invoke the tool.

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

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

For a compliance-chain compute node with no output schema, the description does cover compute modes, chaining inputs, transient-data handling, and points to describe_tool for the schema. What remains missing is what the readiness assessment actually evaluates and how to populate policy_parameters, leaving the core decision function opaque.

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

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

Schema description coverage is 100%, so the schema already documents compute, parent_hashes, parent_tool_ids and policy_parameters. The description largely duplicates the compute-mode semantics and adds chain intent (upstream artifact feeding), but says nothing about policy_parameters beyond deferring to 'the tool's manifest'. Baseline 3 is warranted.

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 by restating the title ('CASP Authorization-Readiness Assessor') and then pivots to infrastructure ('Deterministic OpenChainGraph compute node (compliance_mandate)'). It never states what the assessment actually evaluates or returns; the purpose must be inferred from the sibling artifact names (art-98 fit diagnostic, art-101 own-funds calculator). It is distinguishable from siblings only via those artifact references, not via a clear verb+resource statement.

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?

Chain-position guidance is present ('Consumes upstream artifacts from art-98-mica-casp-fit-diagnostic'), which implies it should run after the fit diagnostic, and the compute-mode semantics (auto/server/browser) are spelled out. However it never says when to prefer this over the many sibling MICA tools (run_mica_casp_fit, calculate_mica_own_funds, check_mica_register_presence), so usage is implied rather than stated.

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

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

Annotations already declare readOnly/idempotent/non-destructive/closed-world, so the safety profile is covered. The description adds genuine behavioral context beyond that: inputs are processed transiently and not stored or logged, compute:'browser' returns a delegation URL, gpu:true nodes always delegate, and an AP2 artifact with execution_hash is exported. This is useful but does not address permissions, failure modes, or the FV-status snapshot's operational role beyond a link.

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 passage is long and dominated by boilerplate: a raw FV-status hash URL, a documentation link, and repeated restatement of compute binding rules. Useful signals (transient processing, upstream artifact consumption) are buried among infrastructure noise rather than front-loaded relative to the tool's actual purpose.

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 4 optional parameters, a nested policy_parameters object, and no output schema, the description defers return-value explanation to describe_tool and to the manifest. It covers compute modes and provenance chaining adequately but leaves the core decision function opaque, which is a gap for a tool whose purpose is an assessment.

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 restates the compute:'auto'/'browser' behavior and points to a manifest for policy_parameters field names rather than enumerating them, which adds little beyond the schema's own parameter documentation.

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 the tool is a 'Model Validation Status Assessor' and an 'OpenChainGraph compute node (compliance_control)' that consumes upstream artifacts from art-451-model-outcome-analysis and exports an AP2 artifact. However, it never explains what the assessment actually computes or decides about model validation status – the name carries the meaning and the body is infrastructure boilerplate. It does not distinguish itself from siblings like compare_model_outcome_analysis, replicate_model_outputs, or compute_eba_im_model_validation_tracker.

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 only usage guidance is 'Use synthetic or anonymised inputs only' and the compute-mode semantics, which are operational rather than selection guidance. There is no statement of when to use this tool versus the many sibling model-validation tools, and no prerequisites or exclusions are given.

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, but the description adds meaningful behavior beyond them: transient processing with no storage, logging, or retention, export of an AP2 artifact with execution_hash for chain provenance, consumption of a specific upstream artifact, and an offline-verifiable FV-status receipt. That is genuine context an agent could not derive from annotations alone.

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 title and the compute-mode rule, which is good, but the opening repeats itself ('OpenChainGraph compute node (compliance_mandate). Deterministic OpenChainGraph compute node.') and a long URL plus a raw hash consume space without helping tool selection. Some sentences do not fully earn their 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 complex compliance compute node with no output schema, the description covers infrastructure concerns well (compute modes, data handling, provenance chaining, FV receipt), but it never describes what the readiness assessment itself checks or the shape of its result. An agent knows how to run it but not what it will tell them.

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 compute enum and parent_hashes/parent_tool_ids are already fully documented in the schema. The description's compute explanation duplicates the schema rather than extending it, and it defers policy_parameters semantics to 'the tool's manifest' instead of clarifying the opaque nested object. Baseline 3 is appropriate.

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

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

The name and title specify a verb and a resource (NAIC AI systems program readiness assessment), which is enough to distinguish it from the many other assess_* siblings. However the description body adds no substance about what the assessment evaluates or produces — it is almost entirely compute-binding and provenance boilerplate. Purpose is conveyed by the name rather than the description.

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 only guidance is 'Use synthetic or anonymised inputs only' and the compute-mode semantics, which are operational rather than selection guidance. There is no statement of when to use this tool versus assess_ai_act_conformity, assess_iso42001_aims_conformance, or other readiness siblings, and no prerequisites.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), and the description adds substantive context beyond them: inputs are processed transiently and not stored/logged/retained, compute:'auto' computes server-side vs compute:'browser' returning a delegation URL, gpu:true always delegates, and an AP2 artifact with execution_hash is exported for chain provenance. That is genuine behavioral disclosure.

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

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

The purpose is buried behind compute-binding and regulatory-deadline metadata, and two full URLs plus a long FV-status hash string consume space without helping an agent decide or invoke. The content is dense rather than padded, but the front-loading is weak.

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

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

With no output schema, the description should carry more of the return-value burden, but it only names the AP2 artifact/execution_hash and downstream consumers. For a 4-parameter node whose nested policy_parameters drive the actual assessment, the lack of any description of what is evaluated or produced leaves a real gap, though safety and provenance are covered.

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

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

Schema description coverage is 100%, so the baseline is 3. The description restates the compute-mode semantics that the schema already documents in detail, and it explicitly defers the policy_parameters field names to 'the tool's manifest', so it adds no meaning beyond the structured 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 title and first line identify the regulatory domain (PSD3/PSR readiness) and the graph node type, but the description never states what the check actually computes, what inputs the assessment consumes, or what it returns. It reads as infrastructure metadata (deadlines, compute modes, provenance) rather than a statement of the tool's job, so an agent knows the topic but not the operation.

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

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

There is no when-to-use guidance relative to the many sibling readiness/assessment tools (assess_mica_casp_readiness, run_dora_readiness_diagnostic, run_t1_readiness_diagnostic, etc.). The only guidance given is a data-handling restriction ('Use synthetic or anonymised inputs only') and a downstream 'output feeds' note, which are not invocation criteria.

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

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

Annotations already cover readOnly/idempotent/non-destructive, and the description goes beyond them: inputs are processed transiently and not stored or logged, execution is deterministic, compute:'auto' runs server-side on Cloudflare Workers while 'browser' returns a delegation URL, and output is an AP2 artifact carrying execution_hash for provenance. These are real behavioral facts an agent needs and are not in the schema or annotations.

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

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

The text is long and jargon-dense, front-loaded with title duplication rather than the actual purpose, and much of it (compute modes, output schema pointer) repeats what the schema already carries. Informative content is buried under infrastructure boilerplate.

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

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

There is no output schema and policy_parameters is an opaque nested object whose field names are only available 'in the tool's manifest,' so the description leaves the core decision-function inputs undefined. It does not compensate with the input semantics an agent would need to call this correctly, and defers to an external URL and describe_tool.

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

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

Schema description coverage is 100%, so baseline is 3. The description restates the compute-mode semantics that the schema already documents ('auto' default, 'browser' forces delegation, gpu:true always delegates) but adds nothing about parent_hashes/parent_tool_ids or the contents of policy_parameters.

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 only statement of purpose is the title 'Restaking Delegation and Slashing Risk Analyzer' restated verbatim; the body then pivots entirely to OpenChainGraph compute-node mechanics. It never says what risk dimensions are assessed, what decision function runs, or how it differs from sibling risk assessors like assess_defi_lending. This is essentially a tautological restatement of the name plus infrastructure boilerplate.

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

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

'Use synthetic or anonymised inputs only' is a data-handling constraint, not usage guidance, and there is no when-to-use/when-not vs alternatives despite dozens of competing assessment tools. The description never explains what kind of restaking delegation or slashing question this tool answers.

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, so the safety profile is covered. The description does add useful behavioral context beyond them: transient server-side processing with no storage/logging, a 'use synthetic or anonymised inputs only' constraint, AP2 artifact export with execution_hash, and upstream chaining from art-113. However, all of this is generic compute-node boilerplate repeated across the family and says nothing about the tool's own decision 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?

A single dense block that front-loads execution mechanics, then embeds a 64-character FV-status hash URL that carries no actionable value for an agent selecting the tool. Template boilerplate (compute modes, AP2 export, transient processing) crowds out the tool-specific purpose.

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

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

No output schema exists, and the description delegates return values to describe_tool rather than explaining them. For a 4-parameter decision node, it omits what the assessment produces, what 'quarantine' means in this context, and which policy_parameters fields are required.

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 4 optional parameters, so the baseline is 3. The description adds nothing to parameter meaning and explicitly punts policy_parameters to 'the tool's manifest for field names', leaving the decision-function inputs undocumented in prose.

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 restates the title ('DSCSA Suspect/Illegitimate Product Quarantine Assessor') and labels it a 'compliance_mandate' compute node, so the resource is named, but it never says what the assessment actually decides (e.g., quarantine/disposition status for suspect product). It is not a tautology, but no sibling differentiation is offered against the many nearby assess_* and verify_dscsa_* 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?

There is no when-to-use or when-not-to-use guidance and no named alternative. The only conditional logic ('compute:auto' vs 'browser') is about execution mechanics, not about when this assessment should be chosen, and that logic is already documented in the schema.

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, but the description adds real behavioral context beyond them: server-side vs browser-delegation semantics, the gpu:true always-delegates rule, transient processing with no storage/logging/retention, and emission of an AP2 artifact with execution_hash for chain provenance. This is genuinely useful disclosure about side effects and execution model.

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 opening is redundant ('OpenChainGraph compute node (compliance_mandate). Deterministic OpenChainGraph compute node.'), and a large share of the text is infrastructure/URL/FV-status hash boilerplate rather than task-relevant guidance. The actual purpose is never front-loaded, so an agent must wade through plumbing before learning anything about what the tool computes.

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

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

There is no output schema, so the description should convey what is returned; it only points to describe_tool for the output schema and mentions an AP2 artifact, without describing the assessment result. For a 4-parameter tool with a nested open-object parameter and a decision function, the description leaves the core computational contract to external artifacts (manifest, describe_tool).

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

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

Schema description coverage is 100%, so the schema already documents compute, parent_hashes, parent_tool_ids and policy_parameters; the description's compute-mode text largely restates the enum description. policy_parameters is an open object whose field names are explicitly deferred to 'the tool's manifest', leaving the substantive input shape undocumented in both places. Baseline 3 is appropriate.

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

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

The description identifies the tool as a 'TRAIGA Exposure Assessor' OpenChainGraph compute node in the 'compliance_mandate' family and names the downstream consumer (art-314-traiga-safe-harbor-pack-builder), which gives some differentiation. However it never states what TRAIGA exposure actually is or what the assessment determines; the substantive content is about compute plumbing, not the tool's purpose. An agent knows the ecosystem slot but not the decision it makes.

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

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

There is no statement of when to use this tool versus siblings like build_traiga_safe_harbor_pack or other assess_* tools. The only prescriptive text is 'Use synthetic or anonymised inputs only', which is a data-handling constraint, not usage guidance. The compute-mode explanation describes mechanics rather than when this tool is the right choice.

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

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

Beyond the annotations (readOnlyHint/idempotentHint/destructiveHint false), the description discloses genuinely useful behavioral traits: inputs are processed transiently and not stored/logged/retained, compute mode governs server vs browser execution and gpu:true nodes always delegate, and the tool exports an AP2 artifact carrying execution_hash. These are substantive context additions rather than restatements of the hints.

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 text is a long run-on blob mixing platform architecture, compute-binding rules, privacy, artifact provenance, a URL, and a 64-hex-character FV-status path. The front-loaded sentence is identity boilerplate rather than purpose, and the embedded hash string is essentially unreadable noise for an agent.

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

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

With no output schema and a free-form nested policy_parameters object whose fields are deferred to an unstated manifest, the description leaves the most important unknown unresolved: what inputs the decision function actually needs. Provenance and execution mechanics are covered, but the core 'what do I pass in to assess the obligation' question is not.

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 parameter definitions already carry the load, establishing the baseline of 3. The description's compute-mode explanation merely paraphrases the schema's own 'compute' description, and for policy_parameters it adds nothing beyond the schema's pointer to 'the tool's manifest'.

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 platform boilerplate ('OpenChainGraph compute node (compliance_mandate)') and effectively restates the name/title rather than stating what the assessment actually computes. It never says what a ViDA DRR reporting obligation is or what the node decides. The only functional hints are the upstream/downstream artifact wiring, which tells an agent where the node sits but not what it does.

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

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

No when-to-use or when-not guidance, and no routing against close siblings such as run_vida_readiness_diagnostic, assess_vida_recapitulative_migration, or validate_vida_einvoice_conformance. The only usage constraint is 'Use synthetic or anonymised inputs only', which is a data-handling rule, not tool selection guidance.

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

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

Annotations already declare readOnly/idempotent/non-destructive/openWorld=false, and the description adds meaningful context beyond them: transient processing with no storage or logging, server-side vs browser delegation semantics for compute modes, an AP2 artifact export with execution_hash for provenance, and an offline-verifiable FV-status receipt. This is above the annotation-covered baseline.

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 identity is front-loaded, but the body is a dense run-on mixing infrastructure, retention policy, provenance, upstream links, and a raw FV-status URL plus hash. Several clauses (the full hash/URL) could be compressed or moved to metadata without losing meaning.

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

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

With annotations, full schema coverage, and no output schema, the definition covers execution mode, data handling, and provenance adequately. It is still incomplete on the substantive gap: what the migration assessment evaluates and what a caller should expect as its decision output.

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

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

Schema description coverage is 100%, so the schema already documents compute, parent_hashes, parent_tool_ids, and policy_parameters. The description mostly restates compute-mode and chaining behavior rather than adding new parameter meaning, and policy_parameters is left to 'the tool's manifest' just as in the schema. Baseline 3 applies.

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

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

The description identifies the resource (ViDA recapitulative-statement migration) and frames it as a compliance-mandate compute node, but never states what the assessment actually decides (e.g., whether/when a migration obligation applies). It does not differentiate from close siblings like assess_vida_drr_reporting_obligation or run_vida_readiness_diagnostic. Purpose is inferable but vague.

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 only usage directive is 'Use synthetic or anonymised inputs only' and a mention of consuming artifacts from art-160-vida-drr-transaction-reporter. There is no when-to-use, when-not-to-use, or routing guidance relative to the several sibling ViDA assessment 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 annotations (readOnly, idempotent, non-destructive, closed-world), the description adds real behavioral context: inputs are processed transiently and not stored or logged, compute:"browser" forces client-side execution and returns a delegation URL, gpu:true nodes always delegate, and the output is an AP2 artifact carrying execution_hash. This is meaningful disclosure that the annotations do not cover. The mention of an offline-verifying FV snapshot is slightly at odds with openWorldHint:false but not an outright contradiction.

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 bloated with infrastructure boilerplate, a raw URL, and a full SHA-256 FV-status path that occupy more space than the functional content. The one useful sentence (transient processing / no retention) is buried, and there is no front-loaded statement of what the tool computes.

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

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

For a tool with a nested, free-form policy_parameters object and no output schema, the description should explain the decision function's subject matter and what inputs are expected. Instead it defers to 'see the tool's manifest' and describe_tool, leaving the core domain semantics and required input shape 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%, so the four parameters are already documented in the schema, including the compute enum semantics, which the description echoes rather than extends. Baseline 3 applies; the description adds no field-name detail for policy_parameters beyond deferring to a manifest.

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

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

The description identifies the tool as an OpenChainGraph compute node (attestation_mandate) that exports an AP2 artifact, but it never explains what 'bulk disbursement integrity' attestation actually does or what it validates. It largely restates the title and names infrastructure rather than the domain action, so an agent cannot distinguish its substantive purpose from siblings like attest_daily_reconciliation or validate_input_attestations.

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 only guidance is 'Use synthetic or anonymised inputs only,' which is an input constraint, not a when-to-use rule. There is no statement of when this attestation is appropriate versus the many other attest_* and validate_* siblings, nor prerequisites or alternatives.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive), and the description adds substantive behavior: inputs are processed transiently and not stored/logged/retained, browser delegation URLs are returned under compute:'browser', gpu:true nodes always delegate, and an AP2 artifact with execution_hash is exported. This is meaningful context beyond the annotations.

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

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

The text is sprawling and front-loads repetitive phrasing ('OpenChainGraph compute node... Deterministic OpenChainGraph compute node'), then embeds a long URL and an FV-status hash. Several sentences restate schema content, and the actual purpose is not front-loaded, so structure is weak.

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 4-param tool with no output schema, the description points the agent to describe_tool for the output schema and mentions the AP2 artifact and execution_hash. However it never explains the actual independence attestation semantics or what the decision function evaluates, leaving an important gap.

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

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

Schema description coverage is 100%, so the schema already documents compute, parent_hashes, parent_tool_ids and policy_parameters. The description restates the compute:'auto'/'browser'/gpu delegation behavior but adds nothing beyond the schema's own descriptions, meriting 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 name and title indicate an independence attestation, but the description never states what the tool actually attests or computes for the calculation agent; most of the text explains compute-node plumbing instead. It identifies the resource (OpenChainGraph compute node / attestation_mandate) but buries the purpose. Not a tautology, but no clear verb+resource statement of the tool's actual decision function.

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 explains compute routing modes and warns to use synthetic/anonymised inputs, but gives no guidance on when to select this tool versus the many sibling attest_* and verify_* tools. There is no when-to-use or when-not-to-use statement relative to alternatives.

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

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

Annotations already declare readOnly, idempotent, non-destructive and closed-world. The description adds genuinely useful behavior beyond that: inputs are processed transiently and not stored/logged/retained, browser delegation returns a URL, gpu:true always delegates, and the FV-status receipt verifies offline. That is meaningful context a agent could not infer 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 purpose is stated first and execution mechanics follow, but the prose is dense with internal vocabulary (compute binding, FV-status hash) and long URLs. Sentences mostly carry content, yet the size is heavy for a tool whose core function is never summarized.

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

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

With no output schema, the description does describe the return artifact (AP2 export with execution_hash) and chaining semantics. But policy_parameters — the actual decision inputs — are punted to 'the tool's manifest', so an agent cannot know what reconciliation fields to supply; the definition is adequate but incomplete for a nested-object compute tool.

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

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

Schema description coverage is 100%, so the schema already documents compute, parent_hashes, parent_tool_ids and policy_parameters. The description reinforces the compute-mode semantics but adds little about parent_hashes ordering or policy_parameters beyond deferring to the manifest, so baseline 3 applies.

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

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

The description identifies the tool as an OpenChainGraph compute node named 'attestation_mandate' and states it exports an AP2 artifact with execution_hash. However, it never states what the daily reconciliation attestation actually computes or decides, leaving the core purpose vague relative to siblings like attest_margin_call_lifecycle and attest_bulk_disbursement_integrity.

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 advises using synthetic or anonymised inputs only and explains the compute modes, which is operational guidance. But there is no when-to-use vs. alternatives routing, no prerequisites, and no indication of which reconciliation scenario this attestation suite is meant for.

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

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

Beyond the annotations (which already declare readOnly/idempotent/non-destructive/closed-world), the description adds real behavioral context: inputs are processed transiently and not stored or logged, synthetic inputs are required, gpu:true nodes always delegate to the browser, and an AP2 artifact with execution_hash is exported for provenance. This meaningfully exceeds structured fields, though it reads as template text repeated across OCG nodes.

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 opening is front-loaded, but the second sentence redundantly repeats 'OpenChainGraph compute node' already stated in the first, and the trailing FV-status URL block is dense and low-signal for tool selection. Each clause is individually informative but the redundancy and URL noise cost structure 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?

With no output schema, the description should explain what the AP2 artifact/response contains, but it only says an execution_hash is exported. It also defers policy_parameters field names to an external manifest, leaving a 4-parameter, nested-object tool materially under-described for correct invocation.

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

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

Schema coverage is 100%, so the schema fully documents compute, parent_hashes, parent_tool_ids and policy_parameters. The description only restates the compute-mode semantics already present in the schema enum and adds nothing about parent_hashes ordering or policy_parameters field names (which it defers to 'the tool's manifest'). Baseline 3 applies.

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

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

The description largely restates the name/title ("Member Margin Call Lifecycle: OpenChainGraph compute node") and then fills the space with infrastructure boilerplate about compute binding and kernels. It never actually says what the margin-call-lifecycle attestation computes or decides, so an agent cannot distinguish the substantive purpose from any sibling compute node.

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

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

There is no guidance on when to choose this tool versus alternatives (e.g. compute_perp_margin, mobilize_margin_collateral, or other attest_* tools). The only conditional guidance concerns compute mode (auto/server/browser), which is parameter behavior, not tool-selection advice.

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/closed-world, but the description adds genuinely non-obvious behavior: transient processing with no storage or logging, deterministic execution, compute:"browser" returning a delegation URL rather than a result, and export of an AP2 artifact carrying execution_hash. That is real disclosure beyond the structured fields.

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

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

PLACEHOLDER

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

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

No output schema exists, and the description compensates partially (artifact shape via AP2 export + execution_hash, pointer to describe_tool for output schema). However, a conformance auditor's core return — pass/fail criteria, rule set, findings — is never characterized, leaving a gap for a reasonably complex, zero-required-param tool.

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

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

Schema description coverage is 100%, so the schema already documents compute, parent_hashes, parent_tool_ids, and policy_parameters. The description's compute-mode text largely mirrors the schema enum description, and for policy_parameters it only redirects to 'the tool's manifest', adding no meaning beyond what is already present.

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 first clause restates the title verbatim ("ACP/UCP Product-Feed Conformance Auditor: OpenChainGraph compute node") and then pivots into compute-binding plumbing. The domain is identifiable from name+title, but nothing explains what 'conformance' actually checks or what the decision function consumes, and no sibling (e.g. validate_agent_commerce_conformance, lint_ucp_checkout_payload, select_agentic_checkout_protocol) is distinguished.

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

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

Usage is only implied via pipeline position (consumes art-19-agentic-checkout-protocol-selector, feeds art-21 and ptg-01) plus the constraint to use synthetic/anonymised inputs. There is no explicit when-to-use vs. when-not, no prerequisites, and no alternative tool named.

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, but the description adds genuinely useful behavior beyond them: server vs browser execution with a delegation URL, transient processing with no storage/logging/retention, and an execution_hash for chain provenance. These are real operational disclosures an agent cannot get from 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 text is long, boilerplate-heavy, and back-loaded: the actual function is never stated while URLs, an FV-status file hash, and 'a snapshot, not a subscription' meta-commentary consume most of the space. Much of it is generic platform boilerplate that does not earn its place for this specific tool.

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

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

For a 4-parameter compliance tool with a nested policy_parameters object and no output schema, the description should explain what the audit computes; instead it defers parameter semantics to an external manifest and explains only plumbing. The mechanical/retention side is covered, but the core semantic content an agent needs to invoke it correctly is missing.

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

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

Schema description coverage is 100%, so the schema already documents compute, parent_hashes, parent_tool_ids, and policy_parameters. The description's compute-mode text duplicates the enum description and it explicitly defers field names to 'the tool's manifest', so it adds no meaning beyond the schema. Baseline 3 applies.

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

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

The description opens by restating the name/title ('Agent Key Rotation Auditor: OpenChainGraph compute node') and then spends its whole budget on infrastructure plumbing (compute modes, delegation, FV-status URL). It never states what the key-rotation audit actually evaluates or what it produces beyond 'an AP2 artifact'. An agent learns it is a 'compliance_mandate' node but not the decision it makes.

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

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

There is no when-to-use guidance versus the 200+ siblings, and no explicit exclusions or alternatives. The only selection hints are mechanical ('output feeds art-133-agent-payment-rail-trust-crosswalk') and a data-hygiene rule ('Use synthetic or anonymised inputs only'), neither of which tells the agent when this tool is the right choice.

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

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

Beyond the annotations (readOnlyHint, idempotentHint, non-destructive), the description adds key behavioral context: the tool renders an interactive widget, runs client-side, and guarantees zero PII and zero network. This materially informs an agent about side effects and security posture.

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 purpose, then usage, and then behavioral details; every sentence earns its place. The note about calling describe_tool to obtain output schema is practical and avoids duplicating structured information.

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

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

For a read-only audit tool with annotations and a single map parameter, the description covers purpose, usage, behavior, and how to obtain the output schema. It does not describe the exact output format, but instructs agents to call describe_tool('audit_mcp_oauth'), which bridges that gap.

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 'inputs' is already documented in the schema as a map of element IDs to values, with schema coverage at 100%. The description adds that inputs are applied via AIN Bridge, but this is more operational context than semantic parameter meaning. Baseline 3 is appropriate.

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

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

The description names a specific verb ('Audit'), a specific resource ('MCP OAuth 2.1 authorization'), and enumerates concrete checks (RFC 9728 metadata, RFC 8707 audience binding, token-passthrough/confused-deputy risk). This clearly distinguishes it from sibling audit tools like audit_mcp_tool_scope_revocation or validate_mcp_authorization_metadata.

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 states a clear when-to-use: 'Use when a developer is securing an MCP server's authorization.' It does not name alternatives or exclusions, but the stated scenario is specific enough for an agent to select this tool over related audit helpers.

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, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description does add real behavioral context beyond them: deterministic execution, transient processing with no storage/logging/retention, a 'synthetic or anonymised inputs only' constraint, and AP2 artifact export with execution_hash. It does not disclose what the audit reports or how policy_parameters are interpreted.

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 prose is boilerplate-heavy and not front-loaded: platform mechanics, a doc URL, and an FV-status hash precede any mention of what the tool is for. Several sentences (gpu:true delegation, FV receipt offline verification) do not help an agent invoke this tool correctly.

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

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

With no output schema, the description should describe what the audit produces, yet it only says an AP2 artifact with execution_hash is exported and points to describe_tool(). For an arbitrary-key policy_parameters object (nested, additionalProperties), an agent has no idea what to pass; deferring to an unnamed manifest leaves the call under-specified.

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 all four parameters are documented in the schema, so the baseline is 3. The description restates the compute enum semantics already in the schema and explicitly punts policy_parameters field names to 'the tool's manifest', adding no semantics the schema lacks.

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 name and title indicate an MCP tool scope/revocation audit, but the description never says what the audit actually inspects, decides, or returns. Almost the entire body describes platform plumbing (compute modes, Workers, chaining) rather than the tool's purpose, so an agent cannot distinguish it from siblings like verify_revocation_status or check_agent_token_scope.

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

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

There is no when-to-use guidance, no prerequisites, and no comparison to any of the many adjacent audit/scope/revocation tools. The only routing signal is a downstream consumer ('Output feeds: art-151-agent-obo-mandate-validator'), which describes chain flow, not when an agent should pick this 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?

Beyond the read-only/idempotent annotations, the description discloses meaningful behavior: it is browser-based, client-side-only, runs with zero PII and zero network, and is rendered as an AINumbers widget with inputs applied via the AIN Bridge. This adds real operational context beyond the annotations.

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

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

The description is front-loaded with purpose and outputs, then gives execution and privacy context. There is some redundancy ('client-side only' and 'zero PII' are repeated), but each sentence still contributes useful information and the structure is clear.

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?

It covers purpose, outputs, architecture, and privacy, and points to describe_tool for the output schema. However, the input contract is opaque—it relies on a manifest and 'input element IDs' rather than specifying the actual fields, so an agent may not be able to construct correct inputs from this definition alone.

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 context about the user-adjustable 1-5 weighting matrix and the 10 dimensions, but it does not enumerate the actual input element IDs or explain how weights are passed through the inputs map.

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 ('Score and compare'), a specific resource ('BaaS providers'), and enumerates exactly what is covered: 10 capability dimensions, a weighting matrix, and the outputs. This clearly differentiates it from generic comparison tools among the 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?

It provides clear context for what the tool evaluates, but it does not state when to prefer this tool over alternatives or when not to use it. The usage is implied rather than explicit, and no sibling comparator tools are referenced.

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, yet the description adds real behavioral context beyond them: server-side vs browser execution rules, that gpu:true nodes always delegate, that inputs are processed transiently and not stored/logged/retained, and that it exports an AP2 artifact carrying execution_hash for chain provenance. This is substantive disclosure for a compute node, though it never states the auth or rate-limit posture.

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 text is dense and boilerplate-heavy: a URL receipt, a long FV-status hash path, and a 'snapshot, not a subscription' caveat that is irrelevant to selecting or invoking the tool. The genuinely useful behavioral sentences are buried after the name/title restatement rather than 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?

For a node with no output schema (deferred to describe_tool) and a nested policy_parameters object, the description does cover execution modes, provenance chaining, and data handling adequately. However it omits the one thing an agent most needs — what the benchmark computes and what policy_parameters should contain — leaving a real gap.

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 each of the 4 parameters (compute, parent_hashes, parent_tool_ids, policy_parameters) is documented in the schema itself. The description's compute-mode prose largely duplicates the schema's enum description, adding no syntax or format detail the schema lacks, so baseline 3 applies.

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

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

The description restates the title ('Transfer-Pricing Interquartile Range Benchmark: OpenChainGraph compute node') and labels the category (compliance_mandate) but never says what the tool actually computes — no verb, no definition of the interquartile range benchmark it produces. An agent cannot tell from this text what output or decision function it exposes, and there are hundreds of sibling compute nodes to distinguish it from, which the description does not attempt.

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?

Only two usage signals appear: 'Use synthetic or anonymised inputs only' and the note that it consumes upstream artifacts from art-472-cbcr-builder. There is no when-to-use/when-not guidance and no comparison to any of the many compute_* or benchmark-adjacent siblings.

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, non-open-world, so the safety profile is covered. The description adds genuinely useful non-annotation context: inputs are processed transiently and not stored/logged/retained, only synthetic or anonymised inputs should be used, and exports carry an execution_hash for chain provenance.

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 opening is front-loaded with the tool identity, but the block then mixes compute placement, privacy, artifact export, an external URL, and an FV-status receipt hash, making it dense and partly boilerplate-heavy rather than tightly focused on what an agent needs to call the tool.

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

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

For a 4-parameter, all-optional tool with no output schema, the description covers compute modes, privacy handling, provenance chaining, and defers return-value detail to describe_tool (a reasonable mechanism). It is close to complete, though the decision semantics of the node itself remain underspecified.

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 restates the compute-mode behavior (also in the schema) and clarifies that parent_hashes/parent_tool_ids drive chain.parent_hashes in the export, but adds little on policy_parameters beyond deferring to the tool manifest.

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 name/title pair ('bind_agreement_acceptance' / 'Agreement Acceptance Binder') conveys the verb and resource, and the description adds that it exports an AP2 artifact with execution_hash and consumes upstream artifacts from art-276-mutual-nda-composer. However, it never states what the 'agreement acceptance' decision function actually evaluates, and it does not distinguish itself from closely related siblings such as bind_attested_subject or build_ap2_cartmandate_hashchain.

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 explains compute placement (auto/server/browser) but gives no when-to-use or when-not-to-use guidance relative to the many alternative binding/artifact tools in the sibling list. An agent is left to infer context from the upstream-consumer note alone.

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

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

Annotations already declare readOnlyHint/idempotentHint true and destructiveHint/openWorldHint false, but the description goes well beyond them: it discloses that inputs are processed transiently and not stored, logged, or retained, that synthetic inputs are mandatory, and that execution can be routed server-side or delegated to the browser. The offline-verifiability note also clarifies that the FV-status snapshot does not create an external dependency, which is consistent with openWorldHint=false. The only omission is what the emitted artifact contains beyond execution_hash.

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

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

The definition is front-loaded with the title and node type, but the body is dense with template-style content: a long spec URL, a 64-character FV-status hash, and a meta-instruction to call describe_tool for the output schema. These occupy space without helping the agent decide or invoke correctly, so the description is longer than its useful payload warrants.

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 4-parameter, nested-object tool with no output schema, the description covers the safety/data-handling story and the compute-routing model, which are the main risks. It nonetheless leaves the actual decision function and the shape of policy_parameters unexplained, pointing to an external manifest, and replaces return-value documentation with a pointer to describe_tool. Adequate but not self-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?

Schema description coverage is 100%, so the schema already documents compute, parent_hashes, parent_tool_ids and policy_parameters in detail. The description largely restates the compute-mode semantics already present in the schema and adds no field-level meaning for parent_hashes/parent_tool_ids ordering or policy_parameters contents (it defers to 'the tool's manifest'). Baseline 3 is appropriate when the schema carries the parameter burden.

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

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

The description identifies the resource class (an OpenChainGraph compute node tagged compliance_control) and the output (an AP2 artifact carrying execution_hash for chain provenance), which is more than a restatement of the title. However, it never explains what 'binding an attested subject' actually computes or what business decision the node performs, so an agent cannot fully distinguish it from the many other bind_*/attest_* siblings. The functional core is left to the spec URL rather than stated.

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

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

The description explains the compute-mode mechanics (auto/server/browser, gpu:true always delegates) and instructs the caller to use synthetic or anonymised inputs, which is invocation hygiene rather than when-to-use guidance. It never says when this binder should be selected over siblings such as bind_agreement_acceptance or validate_input_attestations, nor what preconditions or upstream artifacts are required. No exclusions or alternatives are given.

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 read-only, idempotent, non-destructive and closed-world, and the description adds genuinely new behavioral facts beyond them: deterministic computation, transient processing with no storage/logging/retention, server-vs-browser delegation semantics, and an execution_hash for chain provenance. It stops short of describing the artifact contents, but this is strong added context for a read-only compute node.

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

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

The purpose is front-loaded, but the body carries boilerplate ('OpenChainGraph compute node', 'Deterministic OpenChainGraph compute node' restated), a raw 64-hex-character FV-status URL, and a note about offline receipt verification that does not help an agent select or invoke the tool. It is not padded to the point of unusability, but several sentences do not earn their 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 4-parameter compute node with a nested policy_parameters object and no output schema, the description covers compute modes, chaining inputs, artifact export and data-handling posture, and it routes the agent to describe_tool for the output schema. The remaining gap is that the actual decision inputs inside policy_parameters are documented nowhere (schema uses additionalProperties with no field names), which is material for correct invocation.

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

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

Schema description coverage is 100%, so the schema already documents compute, parent_hashes, parent_tool_ids and policy_parameters; the description's compute-mode text largely restates the schema. The one notable omission is policy_parameters, whose field names are deferred to 'the tool's manifest' rather than explained, but the schema itself already sets that expectation. Baseline 3 applies.

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

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

The description names a specific resource (a 226J response evidence pack) and a specific action (build/export an AP2 artifact), so the verb+resource is present. However, it never explains what a 226J response evidence pack contains or what domain problem it solves, and it offers no differentiation from the many sibling pack builders (build_evidence_pack, assemble_aiuc1_evidence_pack, compile_nav_error_evidence_pack, etc.). Purpose is identifiable but shallow.

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

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

There is real usage context: the upstream artifact it consumes (art-299-aca-esrp-exposure), the instruction to use synthetic/anonymised inputs only, and the compute-mode selection rules. But there is no guidance on when to choose this tool over the near-identical sibling evidence-pack builders, which is the decision an agent actually faces. Implied rather than explicit usage.

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, so the bar is lower, yet the description adds real behavioral detail: transient processing with no storage/logging/retention, browser-delegation behaviour for gpu:true or compute:'browser', and an exported AP2 artifact carrying execution_hash for chain provenance. The FV-status note clarifies the receipt is an offline-verifiable snapshot rather than a live subscription.

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

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

Purpose is front-loaded, but the text is repetitive ('OpenChainGraph compute node ... Deterministic OpenChainGraph compute node') and carries heavy meta-content such as the long FV-status hash path and an external URL that crowd the actionable content.

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

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

There is no output schema, so the description compensates by naming the return shape (computed result vs browser delegation URL) and the exported AP2 artifact with execution_hash, and it routes to describe_tool for the full output schema. Combined with 100% schema coverage on inputs, an agent has enough to call it correctly.

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

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

Schema description coverage is 100%, so the schema already documents compute, parent_hashes, parent_tool_ids and policy_parameters. The description adds only the compute-mode nuance, which is largely duplicated by the schema's own enum description; baseline 3 applies when the schema carries the semantics.

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

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

The description gives a specific verb+resource ('Build Adverse Action Notice') and categorises it as a compliance_mandate OpenChainGraph compute node, and it names the downstream sibling (art-227-validate-adverse-action-notice). It stops short of stating what the notice actually contains or computes, so an agent knows the resource but not the substance of the output.

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 hard usage constraint ('Use synthetic or anonymised inputs only') and explains the compute-mode defaults, and it implies the follow-on tool. However it never states when this tool should be selected versus alternatives, nor any prerequisites beyond the synthetic-input rule.

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, so the bar is lower, and the description adds real behavioral context: inputs are processed transiently and not stored or logged, synthetic inputs are required, compute mode semantics are explained, and the output is an AP2 artifact carrying an execution_hash. That is meaningful operational detail beyond the annotations, though it omits any failure modes or delegation-URL specifics.

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 text is bloated with infrastructure boilerplate, a long FV-status URL and a 64-hex digest, and a pointer to describe_tool, none of which help an agent decide to call the tool. The actual purpose is buried behind compute-mode mechanics, so it is not front-loaded.

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

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

With no output schema and a nested policy_parameters object, the description should clarify returns; it partially does by naming the exported AP2 artifact and execution_hash, and it defines the compute modes. However, it never characterizes the incident-record content itself, leaving a real gap for a compositor tool.

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

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

Schema description coverage is 100%, so the schema already documents compute, parent_hashes, parent_tool_ids, and policy_parameters thoroughly. The description restates the compute-mode behavior but adds no syntax, ordering, or format detail beyond the schema, making the baseline 3 appropriate.

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

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

The description leads with a near-tautological restatement of the name/title ('Agent Incident Record Composer: OpenChainGraph compute node') and never says what an agent incident record actually contains or when it should be composed. It hints at output ('Exports an AP2 artifact with execution_hash for chain provenance') but the core verb+resource purpose is left to inference, and nothing distinguishes it from siblings like build_idv_verification_incident_record or build_ai_decision_log_record.

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?

No when-to-use or when-not-to-use guidance and no named alternative among the many build_* incident/record siblings. The only usage-shaped instruction is 'Use synthetic or anonymised inputs only,' which is a constraint rather than 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 declare readOnly/idempotent/non-destructive, so safety is covered. The description goes well beyond them: it explains server-side vs browser compute routing, that gpu:true nodes always delegate, that inputs are processed transiently and not stored/logged/retained, and that the output is an AP2 artifact with execution_hash and an offline-verifiable FV-status snapshot. This is substantial behavioral disclosure, though the compute-routing details partly duplicate 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.