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?

The description clearly states that inputs are processed transiently, not stored or logged, and recommends synthetic/anonymised inputs, aligning with the readOnlyHint. It also reveals that the output is an AP2 artifact with execution_hash and mentions the output feed, providing useful behavioral details 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 lengthy and repetitive, with phrases like 'OpenChainGraph compute node' appearing twice and extraneous details about Cloudflare Workers, gpu:false, and FV-status URLs. The core purpose is buried under technical infrastructure specifics, making it inefficient for quick comprehension.

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?

While the description explains compute binding and output artifact details, it omits the core domain logic: what constitutes an EMIR reconciliation adjudication, what inputs are expected in policy_parameters, and what the decision output signifies. It also does not clarify how it differs from similar reconciliation tools, leaving the tool's functional context incomplete.

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

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

The schema covers all four parameters with descriptions, and the description elaborates on the compute enum and explains parent_hashes/parent_tool_ids. However, policy_parameters is only described as 'See the tool's manifest for field names', which is vague and requires external lookup, leaving its nested structure incomplete.

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 'EMIR Trade-Repository Reconciliation Adjudicator' but does not explain what 'adjudicate' means in this context. It focuses heavily on the OpenChainGraph compute binding and AP2 artifact mechanics rather than the business purpose, leaving the actual function ambiguous.

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 guidance is provided on when to use this tool versus the many sibling reconciliation tools (e.g., reconcile_emir_pairing, check_emir_uti_completeness). It does not mention use cases, prerequisites, or scenarios where this tool is preferred. The compute mode options are described but not the conditions that warrant using this adjudicator.

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

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

The annotations already declare readOnly, idempotent, openWorld false, and destructive false, and the description is fully consistent with them. It adds material beyond the annotations by explaining deterministic compute semantics, Cloudflare Workers server-side execution, client-side browser delegation, transient non-retention of inputs, AP2 artifact export, and FV-status verification. There is no contradiction between the annotation hints and the description text.

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 carries a lot of important operational context, but it is not tightly structured: OpenChainGraph compute node is stated twice in nearly consecutive sentences, and the FV-status explanation is long relative to the business purpose. The key safety and compute statements are front-loaded, but the redundancy costs it a higher score.

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

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

For a tool with rich annotations and 100% schema coverage, the description gives substantial invocation context: compute modes, delegation behaviour, transient data handling, synthetic-input requirement, upstream dependency, provenance artifact, and FV verification URL. The main gap is that policy_parameters is left opaque and the exact ageing computation output is not described, but the description is still broadly complete for agent selection and 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 the compute, parent_hashes, parent_tool_ids, and policy_parameters semantics. The description restates the compute mode behaviour but does not add meaningful guidance for how policy_parameters should be structured or how parent_hashes and parent_tool_ids need to align. This meets the baseline 3 but does not exceed it.

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 phrase clearly identify this as an EMIR Reconciliation Break Ageing tool and an attestation_mandate OpenChainGraph compute node. It also states that it consumes upstream artifacts from art-482-emir-recon-adjudicator and exports an AP2 artifact with execution_hash, giving it a clear place in a chain. However, it never explicitly says what ageing computation is performed, so the business output remains slightly under-specified.

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

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

The description implies the tool should be run after the upstream art-482-emir-recon-adjudicator artifact is available, and it gives compute-mode selection guidance for auto, server, browser, and gpu:true nodes. It also warns to use only synthetic or anonymised inputs because inputs are transient. It does not name sibling tools such as adjudicate_emir_reconciliation or reconcile_emir_pairing, nor does it explicitly state when not to use 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?

Annotations already indicate read-only, idempotent, non-destructive. The description adds critical behavioral context: client-side execution, no network calls, no PII, uses AIN Bridge for inputs, and renders an interactive widget. This exceeds the information in annotations.

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

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

The description is front-loaded with the main purpose and capabilities. Slight redundancy on 'client-side' and 'zero PII' across two sentences, but remains clear and well-organized.

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

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

Given the presence of an output schema, the description adequately covers purpose, constraints, input mechanism, and execution environment. The mention of 'export result as a Policy Mandate' provides sufficient context for return values.

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 sole parameter 'inputs' has a schema description (100% coverage). The description adds value by explaining it's a map of element IDs to values applied via AIN Bridge prefill, and referencing the manifest input_schema for details.

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

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

The description clearly states the tool simulates agent payment policies with specific capabilities (spend caps, MCC allowlists, velocity throttles, approval thresholds). It distinguishes itself from siblings like 'simulate_spend_policy' by emphasizing it's a sandbox with an interactive widget and client-side execution.

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 specifies the tool is browser-based, client-side only, and zero PII, which implies it's safe for experimentation. However, it does not explicitly mention when to use this tool over alternatives like 'simulate_spend_policy' or when not to use it.

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

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

Beyond the annotations (readOnly, idempotent, non-destructive), the description adds that inputs are processed transiently and not stored/logged/retained, and recommends synthetic or anonymised inputs. This is valuable transparency 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 highly repetitive, stating the same compute-mode behavior and transient-processing note multiple times. It's a dense paragraph with run-on sentences, lacking the concise, front-loaded clarity of a well-structured tool description.

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 provides useful context about chain provenance (parent hashes, upstream/downstream tools) and compute delegation. However, it doesn't describe the expected output artifact structure or the specific decision function inputs under policy_parameters, leaving some gaps for a complex 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?

The input schema already provides full descriptions for all four parameters (compute, parent_hashes, parent_tool_ids, policy_parameters). The description repeats some of this (compute modes, chaining) but adds little new meaning beyond the schema's coverage.

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

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

The title and description clearly state it aggregates CBAM precursor emissions as a chain compute node. However, the description is verbose and doesn't crisply define what 'precursor emissions' means beyond the name, relying partly on the schema.

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

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

It provides specific guidance on compute modes (auto/server/browser) and node behavior (gpu:false vs gpu:true), which is useful. However, it never explicitly compares this tool to any sibling alternatives or states when to prefer this over others, leaving usage context somewhat implicit.

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

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

The description discloses significant behavioral traits beyond the annotations: it explicitly states that inputs are 'processed transiently' and 'not stored, logged, or retained', and it details compute mode execution paths ('server-side on Cloudflare Workers', 'browser delegation URL'). It also mentions determinism and the export behavior. These add substantial value beyond the readOnly/idempotent hints, with no 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 verbose and includes numerous technical details (URLs, FV-status, specific artifact IDs) that may distract from the core purpose. However, it is structurally organized: starting with the purpose, then compute modes, retention, artifact, and pipeline connections. It is not concise but is structured, earning a mid-range score.

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

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

Given the tool's complexity and the absence of an output schema, the description covers essential aspects: compute modes, input retention, artifact export, and pipeline position. It mentions the AP2 artifact with execution_hash for chain provenance, which provides some output expectation. While it doesn't detail the exact artifact structure, the description is sufficient for an agent to understand the tool's role and invoke it correctly.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaningful semantics for the 'compute' parameter by explaining the behavior of each mode ('auto', 'server', 'browser') and the gpu:true exception. For 'policy_parameters' it points to the tool's manifest, which is less useful but still supplementary. It does not elaborate on 'parent_hashes' or 'parent_tool_ids', but the schema already describes them. Overall, the extra context justifies a score above 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 clearly identifies a specific verb (aggregate) and resource (execution receipts), and the title 'Agent-Action Audit-Trail Aggregator' reinforces the purpose. It distinguishes itself through upstream artifact references and the AP2 artifact export, setting it apart from other aggregate_* tools. The core function—aggregating execution receipts into a chain-provenance artifact—is unambiguous.

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

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

The description provides usage context via upstream/downstream dependencies and compute mode behavior, but it does not explicitly state when to use this tool versus alternatives or when not to use it. The guidance is implied rather than explicit, leaving the agent to infer applicability from the pipeline references. No alternatives or exclusions are mentioned.

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?

Exceptionally transparent beyond the annotations: it discloses where computation runs (Cloudflare Workers), delegation rules for gpu:true/false nodes, that inputs are 'processed transiently... not stored, logged, or retained,' includes an explicit 'Use synthetic or anonymised inputs only' warning, and explains the AP2 artifact with execution_hash for chain provenance. It even explains the FV-status verification receipt's offline-verifiability. All of this complements rather than contradicts the annotations (readOnly=true, idempotent=true).

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 dense, unstructured wall of text with no paragraph breaks, bullet points, or hierarchy. The opening is redundant—'OpenChainGraph compute node (compliance_mandate). Deterministic OpenChainGraph compute node.' repeats the same noun phrase twice, suggesting an editing artifact. While dense with useful information (pipeline, URL, FV hash), the lack of structure makes key details (synthetic-only warning, compute behavior) harder to extract.

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 no output schema and an opaque policy_parameters object, the description carries full burden for I/O clarification and partially succeeds: it explains chaining provenance, compute bindings, and verification. But it never describes the shape of the AP2 artifact beyond 'execution_hash,' never lists the critical policy_parameters fields despite having an entire nested object for them, and assumes significant domain knowledge (OpenChainGraph, gpu:false nodes, FV-status). The 50% rule itself is undefined, leaving a material gap for an agent deciding on input construction.

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 every parameter has at least a minimal description, and the description enriches the 'compute' parameter semantics by explaining the default behavior and browser-delegation URL. However, 'policy_parameters' remains a black box—'See the tool's manifest for field names'—with no additional context in the tool description. The description neither compensates for this gap nor meaningfully elevates overall parameter understanding 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 states a specific verb and resource ('Ownership 50%-Rule Aggregator' / 'OpenChainGraph compute node') and clearly scopes it as deterministic and part of a compliance mandate. However, the functional purpose of the 50% rule is never explained in domain terms (beneficial ownership? sanctions look-through?), leaving the agent to infer meaning from upstream/downstream artifact names. The opening is nearly tautological, restating the title rather than defining what aggregation occurs.

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 through pipeline references ('Consumes upstream artifacts from: art-90-sanctions-screening-fit-diagnostic. Output feeds: art-92...'), which situates the tool in a specific workflow. However, no sibling or alternative tool is ever named, and there is no explicit guidance on when to choose this over alternatives like the similarly-named 'compute_cdd_ownership_25pct'. The compute-mode explanation (auto/server/browser) is operational, not usage-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?

Beyond the annotations (readOnlyHint, idempotentHint, destructiveHint), the description discloses determinism, transient input processing with no storage/logging/retention, server-side vs browser delegation behavior, and the AP2 artifact export with execution_hash for provenance. It also notes the FV-status receipt is a snapshot, not a subscription, adding verifiable 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 description is information-dense and front-loaded with the core identity and behavior, but it carries extra material such as the long URL and FV-status JSON path that may not be necessary for tool selection or invocation. It is structured enough, but not every sentence earns its place for an agent deciding whether and how 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?

Given the compute-mode ambiguity, lack of output schema, and chain-provenance behavior, the description covers the essential invocation context: defaults, forced modes, gpu:true behavior, privacy handling, output artifact, and where to find policy_parameters field names. The external manifest pointer and FV-status link fill gaps that would otherwise be unknown. A slightly more explicit statement about required parent hash ordering could raise this further.

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 behavioral meaning around compute modes and references the manifest for policy_parameters field names, but it does not substantially enrich parameter semantics beyond what the schema provides. 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 opens with 'Provable Reputation Score Aggregator' and defines it as a deterministic OpenChainGraph compute node, making the verb, resource, and computing context explicit. It clearly differentiates this tool from other aggregate_* siblings by the reputation-score domain and attestation_mandate framing.

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 concrete guidance on compute modes, explaining when 'auto' computes server-side, when 'browser' forces client-side delegation, and that gpu:true nodes always delegate. It adds a clear operational constraint: 'Use synthetic or anonymised inputs only,' which informs safe invocation. It does not explicitly contrast against sibling aggregate tools, but the unique domain and compute-mode guidance are sufficient.

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

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

The annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds valuable behavioral context: transient processing (inputs not stored, logged, or retained), the compute delegation semantics (browser delegation URL), the requirement to use synthetic or anonymised inputs, the export of an AP2 artifact with execution_hash for chain provenance, and the FV-status verification snapshot. This goes well beyond the annotations and provides critical operational behavior.

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

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

The description is information-dense but not excessively long given the complexity. It front-loads the tool's identity and compute modes, then covers security, output, and verification. Every sentence provides meaningful information; though the URL and FV-status details add length, they're relevant for an agent deciding whether to use this 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 tool with 4 parameters, 100% schema coverage, and rich annotations, the description is fairly complete. It covers compute modes, data handling, output artifacts, and verification. However, it doesn't explain what the actual aggregation input structure should be (policy_parameters fields are only referenced via 'manifest'), and there's no output schema to clarify return values. An agent may still need external reference for the policy_parameters structure.

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 parameters are already well-documented in the schema. The description adds context about the compute parameter's modes and the policy_parameters being computed server-side. However, the policy_parameters description is vague ('See the tool's manifest for field names') and doesn't add meaning beyond the schema's own description. Baseline 3 is appropriate since the schema handles 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 description states the tool aggregates Solvency II SCR standard-formula modules, which is a specific verb+resource. It also clarifies it's an OpenChainGraph compute node with a compliance mandate. However, it doesn't explicitly distinguish itself from the closely related sibling calculate_solvency2_scr_ratio, though it mentions the output feeds into that tool, which provides some differentiation.

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 modes (auto/server/browser) and the conditions under which each is used, which provides clear context for selecting compute parameters. However, it doesn't explicitly state when to use this tool versus alternatives like calculate_solvency2_scr_ratio or other aggregation tools. The output feed mention gives an implicit hint but no explicit when/when-not 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?

The description richly discloses behavior beyond annotations: deterministic execution, compute mode delegation (server/browser), transient processing with no storage/logging/retention, input restrictions, AP2 artifact export with execution_hash, and a provenance receipt. This substantially exceeds what the readOnlyHint and idempotentHint annotations already 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 description is dense but well-organized, front-loading the tool name and category before detailing execution modes, transient processing, output, and links. Each sentence provides functional information, and while it is lengthy, it avoids redundancy. The inclusion of specific URLs and hashes is purposeful for traceability.

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

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

The description covers execution semantics, input constraints, and output provenance, but it does not explain the structure of the AP2 artifact beyond execution_hash or detail the policy_parameters fields. It points to 'the tool's manifest' for more info, so an agent might need to consult external resources. Given no output schema, the return-value description is minimal. This is adequate but leaves gaps for full autonomous 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 baseline is 3. The description adds meaningful context for the compute parameter by explaining 'auto' vs 'browser' behavior and the gpu:true delegation rule. It also indirectly references parent_hashes through chaining and execution_hash, though it doesn't detail all parameters (e.g., policy_parameters). Overall, it elevates understanding beyond the schema alone.

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

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

The name and title clearly imply a liability aggregator for Summa MST, but the description never explicitly states what it aggregates or how. It focuses on execution details (compute modes, transient processing) rather than explaining the core function. It is not a tautology, but the purpose beyond the title is 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?

There is no explicit guidance on when to use this tool versus other aggregators or the inclusion checker. The description mentions the output feeds into art-620-summa-mst-inclusion-checker, hinting at a workflow, but does not state selection criteria or alternatives. Operational constraints like 'use synthetic or anonymised inputs only' are provided, but not when-to-use 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?

Beyond annotations, the description discloses determinism, transient input processing (not stored/logged/retained), the compute-mode delegation behavior for gpu:false vs gpu:true nodes, AP2 artifact export, and chain-provenance via execution_hash. This significantly exceeds what annotations already convey and gives an agent a clear behavioral 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 description is verbose and repetitive: 'OpenChainGraph compute node (model_governance)' and 'Deterministic OpenChainGraph compute node' are near-duplicates, and the long FV-status snapshot explanation and URL add significant length. Useful facts like provenance and privacy are present, but the structure is not tight and front-loads redundant identity rather than the core function.

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

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

The description covers execution mechanics, data-flow relationships, provenance, privacy, and verification links, which is strong for an operational compute node. However, it omits the actual aggregation logic, expected output shape, and the specific meaning of policy_parameters fields, which an agent needs to invoke the tool correctly beyond the schema's generic descriptions.

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 little parameter-level meaning beyond explaining compute modes, and it refers to the manifest for policy_parameters field names rather than enumerating them, though the schema also lacks those details.

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 it as a Taxonomy KPI & Green Asset Ratio aggregator and an OpenChainGraph compute node. It names its upstream artifact (art-73-taxonomy-alignment-scorer) and downstream consumer, which helps distinguish it from the many other aggregate_* siblings. However, the description never states the actual computation or output definition in a clear verb+resource sentence.

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 concrete context by naming upstream and downstream artifacts and specifying compute-mode behavior, and it warns to use synthetic/anonymised inputs only. It does not explicitly say when to choose this tool over alternatives or when not to use it, so the usage guidance is implied rather than explicit.

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

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

The description adds notable behavioral context beyond annotations: inputs are processed transiently and not stored, compute modes alter execution location, and the tool exports an AP2 artifact with execution_hash. These traits are not fully captured by readOnlyHint and idempotentHint. The description is consistent with annotations (no contradiction) and provides useful operational detail.

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

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

The description is a single dense paragraph crammed with URLs, hashes, and technical details that obscure the core purpose. It front-loads compute-mode mechanics rather than stating what the tool does. Much of the FV-status and upstream-artifact information is tangential for a quick understanding and could be moved elsewhere.

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

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

The description covers many operational aspects (compute modes, transient processing, artifact export, upstream artifacts, open link, verification status) that are relevant for correct invocation. However, it omits the actual domain semantics of IHB and references a 'manifest' for policy_parameters without linking it, leaving a gap in understanding the decision function. Given the schema and annotations, it is mostly complete but not fully self-contained.

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

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

The schema already documents all four parameters with 100% coverage. The description adds some context about the compute parameter (default behavior, server vs browser) and mentions that policy_parameters are computed server-side, which slightly reinforces schema descriptions. However, it does not clarify parent_hashes/parent_tool_ids beyond what the schema states, so the added value over the schema is modest.

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 labels the tool as an 'OpenChainGraph compute node' but never states what IHB Interest Allocation actually does — it never defines IHB or explains what 'allocating interest' means. It focuses on execution environment (compute modes, browser delegation) rather than the domain function, so an agent cannot understand the tool's core purpose from this text. It is not a tautology, but it is 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 description mentions compute modes and upstream artifact dependencies but gives no guidance on when to invoke this tool versus any alternative. It does not name sibling tools or specify conditions that would select this tool over other allocation or compute tools. There is no 'when to use / when not to use' 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?

The annotations already cover readOnly and idempotent, but the description adds significant behavioral detail: deterministic execution, compute-mode delegation to server vs browser, gpu:true always delegating, transient processing with no retention/logging, and a directive to use synthetic or anonymised inputs. It also discloses output provenance via execution_hash and an AP2 artifact.

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 verbose and repetitive: it says 'OpenChainGraph compute node' twice, and includes peripheral provenance/offline-verification details that are not directly about how to invoke the tool. The essential behavioral content could be stated in three sentences; the current structure is front-loaded with identity rather than actionable function.

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

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

Despite a fairly rich schema, the core behavior of ASC 340-40 amortization is absent: the description does not say what inputs the decision function requires, what output shape the AP2 artifact carries, or what the amortization schedule contains. Sending the agent to an external manifest and an HTML page is insufficient for correct invocation when there is no 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?

The input schema has 100% description coverage, so the baseline is 3. The description mostly restates the compute-mode choices already documented in the schema and defers the actual policy_parameters fields to 'the tool's manifest', adding little semantic meaning for the agent. It does not help the agent know what values to supply for the real amortization inputs.

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 repeating the name and title ('ASC 340-40 Commission Amortization') and labels the tool as an 'OpenChainGraph compute node', but it never states in plain terms what behavior or output the tool computes. It emphasizes determinism, compute modes, and provenance while omitting the actual amortization function, which distinguishes it poorly from siblings like compute_deterministic_amortization_schedule and build_amortization_schedule.

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 mentions a compliance mandate and names an upstream artifact (art-266-reconcile-commission-statement), which faintly implies chaining after reconciliation. However, it gives no explicit instruction on when to use this tool versus similar siblings, no exclusion conditions, and no guidance on the expected workflow.

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

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

Annotations already declare readOnlyHint:true, idempotentHint:true, destructiveHint:false, and openWorldHint:false. The description adds valuable context on top: transient processing (inputs not stored/logged/retained), execution_hash provenance, and FV-status verification that is a snapshot not a subscription. However, the four compute/browser/gpu behaviors are already detailed in the input schema for the compute parameter. The description doesn't add beyond what the schema and annotations provide in that regard. It does add the 'use synthetic inputs only' guidance and the AP2 artifact export. No contradiction with annotations; it consistently describes a read-only deterministic operation.

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

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

The description is a single dense block that front-loads the title and compute behavior, which is good. However, it's verbose and mixes multiple concerns: compute routing (already in schema), provenance (execution_hash), FV-status, and the URL. The FV-status snapshot explanation is tangential and could be moved or shortened. Several sentences restate schema content (auto/server/browser behavior) rather than adding new value. It is not as concise as it could be, though it is structured with the important compute constraint near the front.

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 explain what the tool returns. It mentions 'Exports an AP2 artifact with execution_hash' but doesn't describe the cost-benefit output structure or what an agent should do with the result. The inputs are only referenced via 'see the tool's manifest for field names' in the schema, and the description doesn't resolve that. For a complex decision-function tool nested with `policy_parameters`, an agent would need field names for the policy parameters (e.g., amounts, tenors, rates) to call it usefully. The provenance and FV-status details are thorough but the core input/output semantics are left dangling.

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 every parameter is documented in the input schema. The description adds marginal context by explaining the default 'auto' path server-side and the browser delegation URL, but that's largely duplicating the schema's enum descriptions. The `policy_parameters` is documented as 'see the tool's manifest' in the schema and the description doesn't add field names or examples, which would have added value beyond schema. It mentions the decision function but doesn't enumerate parameters. Nebula: baseline 3 applies because coverage is high and the description repeats rather than enriches.

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 description clearly identify this as a cost-benefit analysis compute node comparing Documentary Collection vs Letter of Credit. It states it's a deterministic OpenChainGraph compute node and is `compliance_mandate`-specific. It distinguishes itself from the large sibling set by being a compute/analysis node, though it doesn't explicitly name an alternative like `examine_lc_document_presentation` or `validate_mt700_lc_fields`. The purpose is clear, with a specific domain and verb.

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 computation modes (auto/server/browser) and gpu routing in detail, which tells an agent when to expect server-side vs client-side execution. It warns to use synthetic or anonymised inputs only, which is a usage constraint. It does not, however, explicitly say when to use this tool versus other LC/DC-related tools (e.g., `examine_lc_document_presentation`, `validate_mt700_lc_fields`). No alternatives are named, and no exclusions are stated. Some implied usage context exists via the `compliance_mandate` and provenance notes, but it lacks explicit routing.

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

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

The description adds substantial behavior beyond the annotations: inputs are processed transiently and not stored/logged/retained, deterministic execution reinforces idempotentHint, and it discloses the server-side vs. browser-delegation execution model and the AP2 artifact export with execution_hash for chain provenance. All consistent with readOnlyHint=true and idempotentHint=true — no 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 text is verbose and repetitive — 'OpenChainGraph compute node' appears verbatim in the first two sentences — and much of it (Cloudflare Workers, gpu:false/gpu:true flags, FV-status receipt path, offline-verification note, artifact IDs) is peripheral to what the tool does. It is not front-loaded on the core function and contains significant 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 nested policy_parameters object whose field names are only pointed to ('See the tool's manifest'), the description never defines what the analysis returns or what decision-function inputs are accepted. It fully covers execution/provenance mechanics but leaves the actual prediction-market computation semantics unexplained — a real gap for a 4-parameter tool with no output schema.

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

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

Schema coverage is 100%, so all four parameters are already described; the description adds little beyond the schema. The compute parameter's modes are covered in both. policy_parameters remains under-specified — the schema says 'See the tool's manifest for field names' and the description does not reduce that ambiguity — so the high-coverage baseline of 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 first two sentences identify it as a prediction market analyzer ('event_market_pnl') and a deterministic compute node, so an agent can infer it computes prediction-market PnL and is distinct from siblings. However, what it actually produces (a PnL figure, an arbitrage signal) and how it differs from the closest sibling find_prediction_arbitrage is never spelled out, and the purpose is buried under Cloudflare/GPU/kernel jargon.

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-to guidance and no mention of any alternative; the sibling find_prediction_arbitrage is never referenced. The only actionable direction is 'Use synthetic or anonymised inputs only', which is an input-safety constraint, not tool-selection guidance. The OpenAt URL points to external context rather than clarifying selection.

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 behavior, and the description goes well beyond them: inputs are transient and not stored/logged/retained, compute can be server-side or browser-delegated, and the result is an AP2 artifact with execution_hash plus an offline-verifiable FV-status receipt. No annotation 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 dense and front-loaded, opening with the core purpose before compute modes, privacy semantics, output, and verification status. It is long but nearly every clause adds useful operational detail; only the URL/FV-status tail is somewhat auxiliary.

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 no output schema and four optional parameters, the description covers compute behavior, return modes (artifact vs browser delegation URL), data-handling constraints, downstream consumers, and offline verification status. It could be more explicit about the AP2 artifact's exact shape, but the provided information is sufficient for selection and 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 baseline is 3. The description adds a bit of context for the compute parameter (Cloudflare Workers, registered kernel), but it does not add meaning for parent_hashes, parent_tool_ids, or policy_parameters beyond what the schema already describes.

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 a specific resource and operation: an OpenChainGraph compute node for document integrity/eIDAS timestamp anchoring that exports an AP2 artifact with an execution_hash. It is clear what the tool produces, but it never names sibling tools such as anchor_stamp or verify_timestamp_attestation, so it does not explicitly differentiate 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?

The description gives practical routing guidance: compute:'auto' runs server-side on Cloudflare Workers, compute:'browser' forces client-side execution, and gpu:true always delegates to the browser. It also warns to use synthetic or anonymised inputs only. It provides clear context but no explicit when-to-use vs alternative 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 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?

The description adds valuable behavioral context beyond the annotations: it confirms zero PII, client-side only, zero network, and explains it renders as a widget with inputs via AIN Bridge. Annotations already indicate readOnlyHint=true and destructiveHint=false, which are consistent. No contradictions.

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 four sentences and front-loads the core purpose. It efficiently conveys the transformation, execution model, and user link. Minor redundancy between the first and last sentences could be tightened, but overall it is appropriately sized.

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

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

Given the tool's complexity (nested input, output schema exists), the description covers the transformation, execution constraints (client-side, zero PII), and directs users to an interactive version. It addresses the main aspects for an agent to understand and use the tool, though it lacks detail on output structure (output schema not shown).

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 for the single 'inputs' parameter, describing it as a map of element IDs to values. The tool description does not significantly add to that; it repeats 'inputs are applied via the AIN Bridge'. With high schema coverage, baseline is 3.

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

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

The description clearly states it translates AML/BSA controls, TM rules, and customer risk policy into a Policy Mandate JSON. It identifies itself as an 'anchor agentic tool for Cat-12'. However, it does not differentiate from sibling tools like 'build_google_ap2_mandate' which likely has a similar purpose, missing explicit distinction.

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

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

The description provides no guidance on when to use this tool versus alternatives. It mentions 'Cat-12' which implies a specific category but does not explicitly state when not to use it or how it compares to siblings like 'compile_work_mandate' or 'build_google_ap2_mandate'. Usage context 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?

Beyond the annotations, it discloses determinism, server-side vs browser-side compute behavior, transient input processing with no storage/logging/retention, the requirement to use synthetic or anonymised inputs, and the AP2 artifact with execution_hash for provenance. There is no contradiction with the readOnly, idempotent, and non-destructive 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 essential behavior is front-loaded and the description is dense with useful operational details. The FV-status/receipt and URL section at the end add trust/governance context for some agents but are probably not necessary for tool selection and make it slightly longer than the optimal invocation-oriented description.

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 still explains the main output type (AP2 artifact with execution_hash), the upstream/downstream data flow, and the compute delegation behavior. It is not a 5 because the decision function inputs remain unspecified in the description and the actual scenario output returned to the caller is only described abstractly.

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 covers compute, parent_hashes, parent_tool_ids, and policy_parameters. The description adds useful chain context by naming the upstream artifact IDs, but it still defers the actual field names of policy_parameters to an external manifest, so the description only meets 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 an NGFS / Fit-for-55 climate scenario tool that runs as an OpenChainGraph model_governance compute node, and the upstream artifact IDs help separate it from the long sibling list. It is not a full 5 because the description never says explicitly what applying a scenario does to the inputs; the format is inferred from 'AP2 artifact' and '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?

It gives clear use context: it is a deterministic chain node consuming art-68-carbon-compliance-fit-diagnostic and art-71-cbam-certificate-cost-engine artifacts and feeding art-05-agent-action-audit-trail-aggregator. It also explains when server execution is used versus browser delegation. It does not explicitly name alternative tools or say when not to use it, so it is not a 5.

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

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

The annotations convey readOnly/idempotent, which captures some behavior, but the description beyond the annotation is largely a stream of confusion. The text mentions 'Inputs are processed transiently to compute the response and are not stored, logged, or retained', which is a genuine behavioral guarantee. However, it does not meaningfully describe what behavior is exhibited under error conditions or performance, and it introduces references to GPUs and browsers that are more distracting than illuminating.

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, single-paragraph wall of text with no line breaks or visual hierarchy. It front-loads unnecessary details and buries the sparse amount of useful information under a pile of legal boilerplate. The title is the only element that provides structure, and the rest does not build on 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?

Given the complexity of the schema (nested objects, multiple enums), the description fails to provide the missing context for the specific regulatory or computational paradigm the tool operates in. It gives no clear guidance on how the AI addendum should be structured, and the description assumes a level of context that a human would need to know to use 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?

The schema includes individual parameter descriptions which are already descriptive. The tool's description adds minimal signal and doesn't clarify the already-documented rollup of `policy_parameters`. The distinction between `compute` values is preserved in the schema, so the description adds no real semantic value to what's already in the schema, which has a baseline of 3. The overall description reads like a list of names (AI, GPU, browsers) but doesn't provide practical guidance on how to use them.

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 'AI ADDENDUM ASSEMBLER' identifies the deliverable (an AI addendum), but the description immediately descends into a wall of opaque jargon ('OpenChainGraph compute node', 'compliance_mandate', 'deterministic') that obscures more than it clarifies. The core verb-object relationship (assemble + AI addendum) is present but buried under noisy, confusing language, lacking the clarity needed for an agent to confidently discern its 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?

There is zero guidance on when to use this tool versus the massive list of siblings. The description mentions 'use synthetic or anonymized inputs only', but otherwise reads like a series of compliance and technical terms with no actionable insight for when a correct invocation is appropriate, and no explicit 'when/when not' conditions. This is a severe miss for a tool with 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 mark the tool readOnly, idempotent, and non-destructive; the description adds substantial behavioral detail beyond that: determinism, transient processing with no storage/logging/retention, server-side Cloudflare Workers execution, browser delegation behavior, AP2 artifact export with execution_hash, and FV-status snapshot semantics. This is consistent with the annotations and significantly enriches the agent's model of the tool.

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 front-loads compute behavior, which is useful, but it repeats 'OpenChainGraph compute node' twice and includes a URL, a long FV-status hash, and an offline-verification explanation that are not needed for tool selection or invocation. The dense block buries the most actionable details and is not appropriately sized for an agent-facing 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 complex chain node with compute modes, provenance chaining, and no output schema, the description covers the major invocation-relevant facts: compute/delegation behavior, transient input handling, upstream and downstream artifact IDs, and the exported AP2 artifact. It does not fully explain what to put in policy_parameters or the exact response structure, but the schema and manifest pointer partially cover those 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 description coverage is 100%, so the baseline is 3 even without additional parameter guidance in the description. The description mostly restates the compute-mode behavior that the schema already documents. It adds no new field-level semantics for parent_hashes, parent_tool_ids, or policy_parameters beyond what the schema already provides.

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

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

The description identifies the tool as an OpenChainGraph compute node with a compliance mandate and explains its role by naming upstream artifact consumers, downstream outputs, and the AP2 artifact export. It is more specific than a title tautology and gives clear resource/operation information. However, it never states in plain language what assembling an AIUC-1 evidence pack actually entails, so it falls short of 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?

The description gives real usage constraints: 'Use synthetic or anonymised inputs only' and conditional compute-mode guidance for auto/server/browser execution. It also implies pipeline placement via upstream/downstream artifact names. But it does not explicitly say when to choose this tool over similar pack-assembling siblings, nor does it name 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?

The description discloses several behavioral aspects: inputs are processed transiently and not stored, compute mode defaults and delegation rules, the deterministic nature, and the export of an AP2 artifact. It also advises using synthetic or anonymised inputs. These details go beyond the provided annotations (readOnlyHint, idempotentHint) by explaining data handling and compute execution, which is valuable for callers.

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 verbose and repetitive, with significant redundancy (e.g., the compute-mode explanation appears in both the overview and the parameter description). It is structured as a single long paragraph with multiple clauses and technical jargon, making it hard to scan. While it contains useful information, the lack of bullet points or concise sentences hurts readability and conciseness.

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

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

The description provides some workflow context by naming upstream (license-compatibility-checker) and downstream (rights-record-builder) artifacts, and it defines the output as an AP2 artifact with execution_hash. However, it does not explain the purpose of the assembled license terms, the expected content of 'policy_parameters', or how the tool interacts with the broader licensing workflow. Given the absence of an output schema, more detail on the output structure would be needed for full completeness.

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 description adds context to each parameter. For 'compute', it restates and clarifies the enum semantics. For 'parent_hashes' and 'parent_tool_ids', it explains their role in setting chain.parent_hashes and ordering. For 'policy_parameters', it clarifies that these are inputs to the decision function and depend on compute mode, pointing to the manifest for field names. This supplements the schema descriptions, which already cover 100% of 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 description clearly identifies the tool as a 'License Terms Assembler' and mentions its role as an OpenChainGraph compute node with a compliance mandate. However, the purpose is not elaborated beyond the name; the focus shifts to compute modes and provenance rather than the actual assembly logic. It is distinguishable from sibling 'assemble_*' tools by name and upstream/downstream references, but a more explicit statement of the function would earn 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?

The description does not explicitly state when to use this tool versus alternatives. It mentions consuming from 'license-compatibility-checker' and outputting to 'rights-record-builder', which implies a workflow position, but no direct guidance on selection criteria or scenarios. There is no mention of exclusions or when other assemblers would be preferred. This leaves usage largely implicit.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive nature. The description adds substantial behavioral details: inputs are processed transiently and not stored/logged/retained, deterministic execution, compute mode delegation rules, and the fact it exports an AP2 artifact. This goes beyond annotations and clarifies the safety profile 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 description is extremely verbose, packed with infrastructure specifics (Cloudflare Workers, GPU, chain provenance, FV-status) that are likely irrelevant for most callers. The core purpose is front-loaded but the signal-to-noise ratio is low. It would benefit from separating infrastructure details from functional guidance.

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

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

For a compute node with no output schema, the description covers compute modes, input handling, and output artifact format. It references the manifest for policy_parameters but does not explain what the mutual NDA contains. The absence of expected return format and domain details leaves some gaps, but the tool appears intentionally abstract.

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, so each parameter (compute, parent_hashes, parent_tool_ids, policy_parameters) is already documented. The description does not add meaningful new meaning to the parameters; it repeats compute mode behavior already in the enum description. Baseline 3 is appropriate when schema covers everything.

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 sentence clearly state the tool composes a mutual NDA, and it distinguishes from sibling assemble_* tools by specifying 'mutual NDA'. The phrase 'OpenChainGraph compute node' adds context but the core purpose is unambiguous. However, the description is cluttered with infrastructure details that dilute focus on the primary action.

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

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

The description does not explicitly say when to use this tool versus alternatives. It mentions 'Output feeds: art-277-agreement-acceptance-binder' which hints at a chain context, but there is no direct guidance on choosing this tool over other assemble_* or bind_* tools. The compute mode instructions are relevant but not about tool selection.

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 declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, which the description doesn't contradict. It adds valuable behavioral context: transient input processing ('not stored, logged, or retained'), deterministic execution, and the export of an AP2 artifact with execution_hash. It also discloses the FV-status receipt is a snapshot, not a subscription, which is a non-obvious behavioral trait. 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 fairly long (about 7 sentences) but front-loads the core purpose and compute-node nature. Each sentence adds novel information: determinism, compute modes, transient processing, artifact export, URL, and FV-status receipt. Though verbose, it avoids redundancy, and the structure is logical—purpose first, then behavior, then operational details. It earns 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 compute node with no output schema and 4 parameters (0 required), the description covers what an agent needs: what it does, how compute modes affect execution, privacy guarantees, artifact export, and a verification URL. The special warning about synthetic inputs and the snapshot nature of the FV-status are included. There's also a reference to 'the tool's manifest' for policy_parameters fields, which is acceptable given the schema points there. No obvious missing operational information for an agent to invoke it correctly.

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

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

Schema description coverage is 100%, so every parameter (compute, parent_hashes, parent_tool_ids, policy_parameters) already has a description in the schema. The tool description doesn't add much beyond the schema for parameter semantics; it mentions compute modes and execution_hash but doesn't elaborate on parameter specifics. Since coverage is high, baseline 3 is appropriate.

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

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

The description clearly identifies this as an OpenChainGraph compute node for labeling evidence bundle tiers, with the title 'Evidence Bundle Tier Labeler' reinforcing the purpose. It distinguishes itself from siblings like assemble_aiuc1_evidence_pack and build_evidence_pack by mentioning 'attestation_mandate' and the compute node mechanics, but it doesn't explicitly contrast with a specific sibling, so the differentiation is implicit rather than named.

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 concrete guidance on compute modes ('auto', 'server', 'browser') and when each applies, including the gpu:true delegation rule. It doesn't explicitly state when not to use this tool versus alternatives, but the compute-mode explanation effectively tells the agent how to invoke correctly. The warning to use synthetic/anonymised inputs is a clear usage guideline.

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

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

The description states inputs are processed transiently and not stored, logged, or retained, which aligns with readOnlyHint. It also mentions compute modes and deterministic behavior. However, it does not disclose potential error conditions or output behavior.

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

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

The description is verbose and repetitive, repeating the same compute mode and chaining details multiple times. It appears templated and not tailored to this specific tool, containing redundant sentences. This makes it hard to extract the core 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?

Given the tool's name suggests a domain-specific assessment, the description lacks essential context about what constitutes readiness, how to interpret results, or what inputs are relevant. It only covers technical compute binding, leaving the reader without a clear understanding of the tool's function. The absence of an output schema further reduces completeness.

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 provides detailed descriptions for each parameter, including compute modes and parent hashes. The description itself does not add much beyond the schema, but the schema covers 100% of parameters. It references a manifest for policy_parameters field names, which adds some context.

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 mentions 'Agent Directory Publish Readiness Diagnostic' but does not explain what 'publish readiness' means or what it checks. It focuses on compute binding and chaining mechanics, making the actual purpose vague. It does not distinguish from other assess_* 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 guidance on when to use this tool versus alternatives. The description only discusses compute modes and parent hashes, not decision criteria or context. No mention of scenarios 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?

The description goes well beyond the annotations. Annotations say readOnlyHint=true and destructiveHint=false, but the description discloses the critical behavioral details: inputs are 'processed transiently to compute the response and are not stored, logged, or retained', which is a strong privacy statement. It also reveals the deterministic nature, the compute delegation behavior for browser mode, the export of an AP2 artifact with execution_hash, and the feeding of downstream outputs. It also mentions a regulatory deadline affecting behavior. However, it doesn't explicitly confirm idempotency (though annotations say idempotentHint=true) — the description does not contradict that. It also mentions a URL and FV-status receipt, adding provenance context. Given annotations already cover safety, this is strong added context, though it could have explicitly tied the transient processing to the readOnly annotation.

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

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

The description is dense and rich in detail, covering regulatory specifics, compute behavior, privacy guarantees, output links, and provenance. While every sentence adds value, the sheer length (over 200 words) is excessive for a tool description. A front-loaded summary would help: the purpose is announced in the first sentence, but the reader must wade through regulatory legalese, compute specifics, and URLs before reaching the privacy note and downstream feeds. It's well-organized but not concise; the regulatory deadline and compute details could be trimmed or structured. It earns a 3 for being information-dense but lacking the 'appropriately sized' aspect.

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

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

Given the tool's complexity (no output schema, multiple parameters, nuanced compute modes, regulatory implications), the description covers a lot: the regulatory context, compute modes, privacy guarantees, the output artifact type, downstream feeds, and a link for more detail. It even provides an FV-status receipt for verifiability. However, it doesn't explicitly describe the return value structure (though no output schema exists, it could mention what the response contains, e.g., an AP2 artifact with execution_hash — it does, but not the exact response envelope). It also doesn't specify error conditions or whether the `policy_parameters` object has any required fields (schema says none required overall). Given the complexity and absence of output schema, this is fairly complete, but a note on the response format or the main decision output would elevate it. It's slightly above the middle.

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

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

The schema already thoroughly documents all four parameters with 100% coverage, including the enum for compute and descriptions for parent_hashes, parent_tool_ids, and policy_parameters. The description adds semantic value by explaining the compute modes in prose ('auto' = server for gpu:false nodes with registered kernels, 'browser' returns delegation URL, gpu:true always delegates), which clarifies the enum's ambiguous values. It also hints that policy_parameters are 'computed server-side' and points to the tool's manifest for field names, which is complementary. However, it doesn't delve into the structure of policy_parameters beyond what schema states (which is minimal), so the onus is on the manifest. This is better than baseline because it clarifies the compute 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 clearly states the tool assesses conformity with the EU AI Act's credit-scoring provisions, naming the specific regulatory deadline (2027-12-02) and Annex III section. It identifies itself as an OpenChainGraph compute node and distinguishes its deterministic compute behavior. However, it does not explicitly differentiate itself from similarly-named siblings like `assess_ai_act_conformity`'s relatives (e.g., `run_ai_act_highrisk_fit`, `check_ai_act_art50_marking`), nor does it say what the output actually evaluates (conformity versus non-conformity, pass/fail, etc.). The verb is present but the specific assessment criterion could be clearer.

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

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

The description provides substantial context about compute modes (auto/server/browser) and explicitly warns to use synthetic or anonymised inputs only, which is a usage guideline. However, it does not state when to use this tool versus its siblings (e.g., assess_ai_act_conformity vs run_ai_act_highrisk_fit or classify_annex3_decisioning_obligations). It doesn't say under what conditions an agent should choose this tool over another. The compute-mode guidance is useful but not about tool selection.

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), the description discloses transient processing, that inputs are not stored/logged/retained, deterministic behavior, compute delegation rules (server vs browser), and export of an AP2 artifact with execution_hash. These are valuable operational details not captured in annotations.

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

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

The description is dense but well-structured, leading with the core purpose and then detailing execution specifics. It includes a link and FV-status, which are useful, though some sentences could be trimmed without losing critical 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?

The description covers input handling, compute modes, output artifact (AP2 with execution_hash), provenance chain, and provides a link for more detail. Since there is no output schema, it gives a high-level description of the return, which is sufficient for an agent to invoke correctly.

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

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

Schema coverage is 100% as each parameter is described in the schema. The description adds some contextual nuance (e.g., compute mode behavior, pointer to manifest for policy_parameters) but does not significantly deepen meaning beyond what the schema already provides.

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

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

The description identifies the tool as an OpenChainGraph compute node for circumvention diligence, which is clear but relies on the title for the core action. It mentions 'compliance_mandate' and its position in the artifact chain (upstream/downstream), distinguishing it from other assess tools, but does not explicitly state 'assesses circumvention diligence' in a verb+resource form.

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

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

The description provides constraints (use synthetic/anonymised inputs only) and explains compute modes, but lacks explicit guidance on when to select this tool over alternatives. It does not reference sibling tools or conditions for choosing this one, leaving usage decisions to the agent.

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

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

Annotations already mark the tool as read-only, idempotent, and non-destructive, and the description adds substantial behavior beyond that: deterministic execution, server vs browser compute modes, transient non-retained inputs, AP2 artifact export with execution_hash, and FV-status snapshot/offline verification. No contradiction with annotations.

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

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

The description is dense and repetitive: 'OpenChainGraph compute node' appears twice, and compute-mode details duplicate the input schema. The valuable privacy and FV-status information is buried in a long block, making the description harder to scan.

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

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

Despite rich execution mechanics, the description never explains what 'readiness' means, what the output artifact contains beyond execution_hash, or what fields policy_parameters requires—it defers to a manifest. With no output schema, an agent cannot fully determine the expected result or how to construct valid inputs.

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 mostly restates compute-mode semantics already present in the schema and defers policy_parameters field names to a manifest, adding little meaning beyond what the schema provides.

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

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

The description identifies the tool as an OpenChainGraph compute node for CRA Vulnerability Reporting Readiness (Art. 14), but the actual assessment function is never stated with a specific verb like 'assess' or 'compute readiness'. It relies heavily on the title for meaning and does not differentiate itself from the many sibling assess_*_readiness tools.

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

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

The description provides some usage context: it consumes upstream artifacts from art-139-cra-annex1-completeness-checker and instructs users to use synthetic or anonymised inputs only. However, it never explicitly states when to prefer this tool over alternatives or when not to use it, leaving the selection criteria largely 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?

The description adds significant behavioral detail beyond the annotations. It explains the `compute` parameter's effect on execution location. It clearly states data is processed transiently and not stored. It specifies the output is an 'AP2 artifact with execution_hash', which is a key contract detail. This substantially exceeds what annotations alone tell us.

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 front-loads key info but gets mired in operational details (Cloudflare Workers, FV-status) and promotional copy ('Open at: ...'). The FV-status URL and explanation, while potentially important, consume almost half the description and feel out of place. This could be tighter or put this info behind a link. It works, but it's bloated and could be more focused.

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 an analytics tool with a full schema and clear annotations, this description is complete for the core use case: it covers the compute modes, data privacy, and output format. It's missing context on what 'DeFi Lending Health' means in practice (e.g., key metrics), and the LinkedIn/Cloudflare details are noise. But nothing critical is missing for a basic call.

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

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

The schema has 100% coverage of parameters, so the baseline is 3. The description adds useful context on the `compute` parameter ('auto' default, server vs. browser execution), and the overall privacy guidance explains why one might choose a particular mode. The FV-status detail also adds context on output verification. It doesn't explain `parent_hashes` or `parent_tool_ids` beyond the schema, but the schema covers these fully.

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

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

The description clearly states the tool monitors DeFi lending health and liquidation, and that it's an OpenChainGraph compute node. The title reinforces this. While it provides the resource and purpose, it doesn't explicitly differentiate from siblings like `run_chain`, `build_chaingraph`, or other `assess_*` tools, which is a missed opportunity for clarity.

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's an implicit indication of use (with the compute modes), but no explicit statement about when to use this versus alternatives. While an agent could infer from the 'analytics_mandate' that this is for analytics, the description misses the chance to explicitly state what use cases this tool is for versus siblings, such as whether it's for on-demand checks vs. batch analysis. The FV-status link and note about privacy are good but don't fully cover 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?

The description discloses substantial behavior beyond the annotations: compute modes ('auto' vs 'browser' with server-side execution on Cloudflare Workers), transient processing ('not stored, logged, or retained'), output characteristics ('Exports an AP2 artifact with execution_hash'), and a verification mechanism (FV-status snapshot). This goes well beyond the read-only/idempotent hints and helps the agent understand side effects and execution 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 description is long but dense; every sentence contributes distinct information (purpose, compute behavior, data handling, output, links). It front-loads the title and node type, then layers technical detail. Slightly overpacked, but no redundant filler.

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

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

The description omits what the tool actually returns as a conformance assessment — it mentions an execution_hash but not a verdict or structured result. It also fails to describe what inputs should go into policy_parameters, leaving the agent unable to construct a valid request. With no output schema and a vague parameter schema, the description is incomplete for safe 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?

The schema covers all four parameters with descriptions, and the description echoes the compute enum without adding new meaning. For policy_parameters, the schema already defers to 'See the tool's manifest', and the description does not fill that gap. Schema coverage is 100%, so the description is not required to compensate, but it also adds no extra semantic detail.

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

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

The title 'ISO 42001 AIMS Clause Conformance' and the tool name 'assess_iso42001_aims_conformance' suggest it assesses conformance, but the description itself never explicitly states that it evaluates conformity or what a result looks like. It focuses on compute mechanics ('OpenChainGraph compute node', 'compute binding') rather than the assessment outcome, leaving the core purpose implied rather than stated.

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

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

No guidance is given for when to use this tool versus the many sibling 'assess_*' tools (e.g., assess_ai_act_conformity). The only usage instruction is 'Use synthetic or anonymised inputs only,' which is an input constraint, not a tool-selection guideline. There is no mention of prerequisites, exclusions, or conditions under which an alternative is preferred.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and the description adds meaningful behavior on top without contradicting: deterministic execution, 'processed transiently... not stored, logged, or retained', server/browser routing semantics for the compute param, and the FV-status receipt being 'a snapshot, not a subscription'. The description also previews cross-tool provenance ('Exports an AP2 artifact with execution_hash'), which deepens the agent's trust model. No contradiction — annotation_contradiction is false.

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

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

The first two sentences both say 'OpenChainGraph compute node', which is repetitive and not informative. The description is dense with infrastructure noise — Cloudflare Workers, GPU flags, FV-status receipts, market URLs — while the signal an agent needs (determinism, no-retention guarantee, DAG placement) sits buried in the middle. A tightened version that front-loads 'deterministic, read-only, no retained inputs, part of compliance_mandate chain' would be a major improvement.

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 bears the full burden of explaining return shape, but it only promises 'an AP2 artifact with execution_hash' — leaving the agent blind to the assessment structure. For a compliance/surveillance tool, the description provides no detail on which surveillance dimensions or controls are evaluated, and 'See the tool's manifest' sends the agent nowhere it can follow. Offering FV-status and DAG pointers is nice, but the core 'what does this assess and what do I get back' question goes unanswered.

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

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

Schema coverage is 100%, so the input schema already documents all four params; the description doesn't add meaning for parent_hashes or policy_parameters beyond that. The one real addition is the compute-mode explanation ('auto = server for gpu:false nodes with registered kernels'), which does clarify the compute enum. However, policy_parameters defers to 'the tool's manifest' — a resource an agent at runtime cannot access — which is a missed opportunity to encode that semantic meaning directly.

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

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

The description does name a specific verb-resource pair ('MAR-Crypto Surveillance-Readiness Assessor') and a compute mechanism, but it leans on implementation detail ('OpenChainGraph compute node (compliance_mandate)') rather than telling an agent what an assessment checks or what makes it distinct. Crucially, the agent cannot distinguish this from siblings like run_mica_casp_fit or assess_mica_casp_readiness without opening the schema — and with ~400 siblings, that's a real miss. Purpose is clear at a high level, but differentiating context is absent.

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

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

Provides genuine contextual signal for when this tool runs: it sits in a DAG ('Consumes upstream artifacts from: art-98-mica-casp-fit-diagnostic. Output feeds: cry-05-agent-action-audit-trail-aggregator'), which is useful placement info an agent can reason about. It also states a hard constraint ('Use synthetic or anonymised inputs only'). However, it stops short of explicit when-to-use vs alternatives — it never says 'use this instead of run_mica_casp_fit when X' — and gives no exclusions or preconditions.

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

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

Beyond annotations, the description discloses determinism, transient processing with no storage/logging/retention, server-side vs browser delegation behavior, AP2 artifact export with execution_hash, upstream/downstream chain relationships, and FV-status as a snapshot rather than a subscription. No information contradicts the readOnlyHint or idempotentHint 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 information-dense but somewhat long and repetitious, repeating the 'OpenChainGraph compute node' framing. Operational details like the full URL and FV-status hash are packed into long trailing sentences, so the message is structured but not tightly front-loaded around the primary 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?

For a compute node with zero required parameters and an execution-model, the description covers compute binding, privacy, provenance, artifact flow, and verification status. The main gap is the output side: there is no output schema, and description only hints at the output via the AP2 artifact without explaining what the readiness assessment actually 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?

The input schema documents all four parameters with descriptions, so the baseline is 3; the tool description itself adds very little parameter-level meaning beyond the schema. The policy_parameters object remains an opaque bag whose actual field names are deferred to the tool manifest, which limits semantic completeness.

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 description clearly identify the role of the tool as a CASP authorization-readiness assessor and locate it as an OpenChainGraph compute node with a compliance mandate. It is not a tautology, but the description does not give a crisp functional sentence about what the readiness output actually means, and it does not distinguish this tool from related siblings such as run_mica_casp_fit.

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

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

The description provides concrete usage context: it is a chain node consuming art-98 and art-99, feeding art-101 and cry-05, and it instructs users to supply synthetic or anonymized inputs only. It does not explicitly tell the agent when to use this tool instead of related assess/fit/route siblings, and no when-not-to-use guidance is 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 declare readOnlyHint, idempotentHint, and non-destructive. Description goes beyond: explains deterministic behavior, processing is transient (not stored/logged/retained), compute routing semantics, and the FV-status receipt being a snapshot not a subscription. This significantly exceeds what annotations provide alone. Minor gap: no mention of rate limits or authorization requirements (though the FV-status URL and OpenChainGraph context imply public read access).

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

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

The description is very long and dense, mixing multiple concerns (computing semantics, data handling, artifact provenance, FV-status receipt URL). It front-loads the compute node identity but then buries a critical safety instruction ('Use synthetic or anonymised inputs only') in the middle. While every sentence carries information, it lacks structural hierarchy; a human or agent would benefit from bullet points or clearer sections.

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

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

Given the tool's complexity (4 params, nested policy_parameters object, compute routing), the description covers the main points: compute modes, transient processing, parent hash chaining, artifact export, upstream consumption, and FV-status snapshot. But there's no output schema, so the agent doesn't know what the response looks like (beyond 'browser delegation URL' or an AP2 artifact). Also missing: what happens on failure, what the AP2 artifact name/semantics is, or how to handle errors — for a tool this intricate, that's a gap. The FV-status URL and long hash add operational detail but don't tell the agent how to interpret the result.

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

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

Schema description coverage is 100% — every parameter (compute, parent_hashes, parent_tool_ids, policy_parameters) already has a description in the schema. Description adds context on compute modes and policy_parameters server-side computation, but mostly restates the schema. Per the rule, baseline is 3 since schema coverage is high; no additional benefit beyond restating.

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 description clearly state this is a compute node for model validation status assessment, part of the OpenChainGraph compliance_control infrastructure. It distinguishes itself as a deterministic node with a specific artifact export (AP2 with execution_hash). However, it does not explicitly differentiate from any specific sibling tools — it's hard to tell exactly which of the many nearby tools (like assess_iso42001_aims_conformance, run_model_test_battery) it should be used instead of. The description reads more like an infrastructure/specification document than a plain-language purpose 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?

The description gives explicit behavioral routing: compute:"auto" defaults to server-side for gpu:false nodes with registered kernels; "browser" forces client-side and returns a delegation URL; gpu:true always delegates to browser. It also states inputs are transient and not stored, and instructs to use synthetic or anonymized inputs only — a clear guideline for safe invocation. It names the upstream artifact it consumes (art-451) and provides the artifact URL.

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 and idempotent. The description adds that inputs are 'not stored, logged, or retained' and advises using synthetic data, which provides additional behavioral context. However, the description is verbose and includes confusing jargon about 'OpenChain compute nodes' that obscures the behavior.

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

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

The description is excessively long and repetitive, including URLs, hashes, and generic template text. It is not front-loaded with the core purpose and reads like a dump of metadata. Structure is poor, with run-on sentences and irrelevant details.

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

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

Given the lack of an output schema, the description does mention it exports an AP2 artifact with an execution_hash, giving some output context. However, it does not explain what the artifact contains or what 'readiness' means. The description is more about the compute framework than the actual assessment, leaving the core purpose incomplete.

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

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

The schema descriptions cover 100% of parameters, with compute and parent_hashes reasonably explained. policy_parameters is vague, referring to 'the tool's manifest.' The description repeats compute mode details but adds nothing for the other parameters, so the schema carries the load.

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 indicates assessment of NAIC AI Systems Program readiness, but the description is dominated by infrastructure details (compute modes, parent hashes, AP2 artifacts) and never clearly states what the tool actually evaluates or produces. It fails to distinguish itself from the many other 'assess_*' sibling tools beyond 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?

The description provides no guidance on when to use this tool versus alternatives. It discusses compute modes and chain provenance but does not mention scenarios where NAIC readiness assessment is needed or how it differs from similar 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 (readOnlyHint, idempotentHint, destructiveHint), the description discloses crucial runtime behavior: 'Inputs are processed transiently to compute the response and are not stored, logged, or retained', gives an explicit usage directive ('Use synthetic or anonymised inputs only'), describes compute routing, chain provenance ('Exports an AP2 artifact with execution_hash'), and covers the FV-status verification mechanism with snapshot semantics. This meaningfully enriches the annotations without 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 dense but unstructured and contains redundancy: 'OpenChainGraph compute node' appears verbatim twice ('compliance_mandate' wrapper and 'Deterministic OpenChainGraph compute node'). Compute-mode behavior is restated in both the description and the schema. The ~250-word run-on crams regulatory deadlines, platform details, provenance, URLs, and verification logic into one block without paragraph breaks. Every sentence carries information, but the wall-of-text presentation and duplication keep it from being 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 tool with no output schema, the description covers a great deal: computation semantics, data-retention posture, the synthetic-input directive, the AP2 artifact output with execution_hash, and downstream consumers. The remaining gap is the shape of the full response envelope (e.g., how the browser delegation URL is returned alongside the artifact, or what the readiness decision response looks like) — a modest omission given the otherwise rich coverage.

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 each parameter (compute, parent_hashes, parent_tool_ids, policy_parameters) already has informative descriptions. The tool description does little to enrich parameter understanding — its compute-mode prose largely mirrors the schema's own documentation ('By default (compute:"auto") inputs are computed server-side...'). The only marginal addition is pointing policy_parameters consumers to 'the tool's manifest for field names'. Per the high-coverage baseline of 3, this 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 opens with a clear, specific subject ('PSD3 / PSR Readiness Checker') and grounds it in concrete regulatory detail: 'Regulatory deadline: 2027-06-01 (EU PSD3 expected transposition ~2027; UK PSR enacted 2024 (APP reimbursement Oct 2024 already live))'. It further positions the tool in a pipeline by naming its output feeds ('art-04-agent-identity-attestation-checker, ptg-01-ap2-prompt-template-generator'), which differentiates it from the many sibling readiness checkers.

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

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

The description clearly frames when to use this tool (PSD3/PSR readiness assessment with a hard regulatory deadline) and explains execution-context behavior ('compute:"auto" inputs are computed server-side on Cloudflare Workers for gpu:false nodes with a registered kernel'). However, it never explicitly contrasts itself with the numerous sibling readiness tools (run_dora_readiness_diagnostic, run_vida_readiness_diagnostic, etc.), leaving the agent to infer differentiation from the regulatory framing 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?

The description adds substantial behavioral context beyond the annotations: deterministic execution, server vs browser compute delegation, transient input processing with no storage or logging, and AP2 artifact export with execution_hash for provenance. It also explicitly warns to use synthetic or anonymised inputs. This meaningfully exceeds what readOnlyHint and idempotentHint already communicate.

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 overlong and contains redundancy, including the repeated 'OpenChainGraph compute node' phrasing in the first two sentences. It also buries practical invocation information under a long FV-status URL and snapshot discussion that is not needed for selecting or calling the tool. It is structured, but not concise.

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

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

There is no output schema, and the description does not explain what the returned risk assessment contains or how policy_parameters should be populated; the schema punts on this with 'See the tool's manifest for field names.' The description covers compute modes and data handling well but leaves the core analytical contract under-specified for an agent.

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 schema already explains compute, parent_hashes, parent_tool_ids, and policy_parameters in reasonable detail. The description mostly restates compute-mode behavior already present in the schema and adds only a general privacy warning about synthetic inputs. It does not add field-level meaning beyond the schema, so baseline 3 is appropriate.

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

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

The name and title make the intended domain clear: assessing restaking delegation and slashing risk. The description adds that it is a deterministic OpenChainGraph compute node exporting an AP2 artifact, which gives some functional identity. However, it never plainly states what analysis is performed or what the result represents, so it is clear but not fully explicit.

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

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

The description gives no when-to-use guidance and names no alternatives among the many assess_*, compute_*, or run_* sibling tools. The compute-mode explanation is operational detail, not selection guidance. The only usage constraint is 'use synthetic or anonymised inputs only', which is not enough to guide tool selection.

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

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

The description adds significant behavioral context beyond the annotations: it explicitly states determinism, transient processing with no storage/logging/retention, the requirement to use synthetic or anonymised inputs, the export of an AP2 artifact with execution_hash for chain provenance, and the FV-status snapshot verification behavior. These details go beyond the readOnlyHint, idempotentHint, and destructiveHint annotations, providing the agent with important safety and provenance information.

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

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

The description is dense and includes many technical details (compute modes, Cloudflare Workers, browser delegation, AP2 artifact, FV-status URL). While it is structured and includes some front-loaded information, it is not concise; several sentences could be streamlined (e.g., the URL and FV-status details might be better placed in separate metadata). It is adequately organized but longer than necessary for an MCP description.

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

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

Despite the high parameter count and nested object, the description leaves critical gaps: it does not specify what the tool actually computes or the structure of policy_parameters (only pointing to a manifest), and it does not describe the response/output. The agent lacks enough information to correctly invoke the tool, especially how to construct the policy_parameters object. The provenance and compute details are useful but do not compensate for the missing functional specification.

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 adds some context by mentioning 'Consumes upstream artifacts from: art-113-saleable-returns-verifier,' which hints at what parent_hashes should reference. However, it does not elaborate on the meaning of policy_parameters, merely directing to 'the tool's manifest.' Thus, the description adds marginal value beyond the schema but does not fully compensate for gaps in explaining the policy_parameters 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 identifies the tool as a 'DSCSA Suspect/Illegitimate Product Quarantine Assessor' and as a compute node, but it never explicitly states what it does (e.g., 'assesses whether a product is suspect/illegitimate and determines quarantine status'). The focus is on execution mechanics (compute modes, browser delegation) rather than the core functionality. While not a tautology, the 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 guidance on when to use this tool versus alternatives. The description does not mention any related sibling tools (e.g., verify_dscsa_transaction_statement, verify_product_authenticity) or state conditions for using this tool over others. It only explains compute mode selection, which is about internal execution rather than tool selection.

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

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

Annotations already mark readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds meaningful behavioral context: inputs are processed transiently and not stored/logged/retained, outputs are deterministic and produce an AP2 artifact with execution_hash, and the FV-status receipt is a snapshot not a subscription. This goes beyond the annotations and helps the agent understand side effects, privacy, and provenance behavior.

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

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

The description is dense but every sentence carries load-bearing information: identity, determinism, execution modes, transient processing, output artifact, downstream feed, URL, and verification status. The long verification hash and URL add specificity but make it slightly heavy; the structure is front-loaded with the core identity and execution semantics. It earns a high score but loses one point for the abrupt embed of the FV-status URL/hash without labeling it as a separate verification consideration.

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, read-only, idempotent compute node with no output schema, the description is largely complete: it explains what the tool does, how compute is selected, what the output feeds, and how to verify the artifact. The only gap is that it never explains what TRAIGA exposure assessment actually evaluates or what inputs are expected beyond generic policy_parameters; an agent may not know what to pass. The high schema coverage and clear behavioral guarantees reduce the severity of 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?

Schema description coverage is 100%, so the schema already documents all four parameters well, including the compute enum semantics and parent_hashes/parent_tool_ids chaining. The description adds value by explaining the compute modes at a higher level (auto/server/browser, gpu:false vs gpu:true) and noting that policy_parameters are computed server-side depending on kernel registration. It doesn't enumerate policy_parameters fields, but it correctly defers to the manifest. With full schema coverage and the added compute-mode context, a 4 is appropriate.

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

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

The description names a specific resource and operation: it is a deterministic OpenChainGraph compute node for TRAIGA exposure assessment under a compliance mandate. It distinguishes itself from siblings by naming its output feed (art-314-traiga-safe-harbor-pack-builder) and providing a direct URL. It is clear this is a compute/assessment tool, not a check or build tool.

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 explicitly explains when server-side vs browser-side execution occurs: default 'auto' computes server-side on Cloudflare Workers for gpu:false nodes with a registered kernel; 'browser' forces client-side and returns a delegation URL; gpu:true always delegates. It also warns to use synthetic or anonymised inputs only. It doesn't name sibling alternatives, but for this unique compute node the execution-mode guidance is the key usage context and it is fully specified.

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

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

Beyond the readOnlyHint, idempotentHint, and destructiveHint annotations, the description discloses determinism, transient processing with no storage or retention, server-side Cloudflare Workers execution versus browser delegation, and the gpu:true delegation rule. It also explains the AP2 artifact export with execution_hash and that the FV-status receipt is a snapshot, not a subscription. No statement contradicts the annotations.

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

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

The description is dense and roughly ordered from compute behavior to privacy to provenance, but it repeats OpenChainGraph compute node and includes a long FV-status aside that is tangential to calling the tool. Trimming redundant qualifications would make the core selection signals easier to scan.

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 indicate that an AP2 artifact with execution_hash is exported and provides upstream and downstream artifact IDs, a URL, and an FV-status link. However, it does not describe how the reporting-obligation result is represented, what policy_parameters fields are valid, or whether parent_hashes and parent_tool_ids are required for a valid call.

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

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

Schema coverage is 100%, so the baseline applies because the schema already documents compute, parent_hashes, parent_tool_ids, and policy_parameters. The description's compute-mode explanation mostly duplicates the schema enum descriptions and adds little about the parent_hashes or parent_tool_ids fields. policy_parameters contents are still deferred to an external manifest rather than clarified.

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 ViDA DRR Transaction Reporter and OpenChainGraph compute node, which mostly restates the tool's name and title rather than stating what assessment it performs. It never clearly says whether this tool determines if a ViDA DRR reporting obligation applies or what business conclusion the returned artifact supports. The upstream and downstream artifact references hint at its position in a compliance chain but do not define the core 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-mode selection and instructs users to provide synthetic or anonymized inputs, but these are operational constraints rather than criteria for choosing this tool over siblings. It does not name related alternatives such as assess_vida_recapitulative_migration or validate_vida_einvoice_conformance, and it does not state the scenario in which the DRR reporter is the correct node to call.

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

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

The description adds substantial behavioral context beyond the annotations: deterministic execution, server-side vs. browser-side compute delegation, transient non-retained input processing, AP2 artifact export with execution_hash, and upstream artifact consumption. These details enrich the readOnly/idempotent/non-destructive hints without contradicting them.

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

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

The description is dense and information-rich, but it repeats 'OpenChainGraph compute node' in the first two sentences and includes long provenance/FV-status details that are not essential for invocation. It is structured in useful chunks, though some redundancy and peripheral detail could be trimmed.

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

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

Despite rich provenance and compute-mode detail, the description omits what the assessment output actually looks like and does not explain how to populate policy_parameters. With no output schema and a nested policy_parameters object, an agent would struggle to know what a successful response contains or how to construct a meaningful request beyond choosing compute mode.

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 reinforces the compute-mode semantics already present in the compute parameter but adds no field-level meaning for parent_hashes, parent_tool_ids, or policy_parameters beyond what the schema supplies.

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 labels the tool as an 'OpenChainGraph compute node' with a 'compliance_mandate' and notes that it consumes upstream artifacts and exports an AP2 artifact, but it never states what actually gets assessed or what a 'recapitulative statement migration assessment' produces. This largely restates the name with technical jargon, so an agent cannot distinguish its domain function from the title alone.

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

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

There is no explicit guidance on when to use this tool versus alternatives. The only usage-related content covers compute-mode behavior and a synthetic/anonymised input warning, but nothing routes the agent away from sibling tools like assess_vida_drr_reporting_obligation or run_vida_readiness_diagnostic.

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?

Substantial behavioral disclosure beyond the annotations: inputs are processed transiently and never stored/logged/retained, the tool is deterministic, gpu:true forces browser delegation, and the FV-status receipt verifies offline as a snapshot rather than a subscription. None of these contradict the readOnlyHint, idempotentHint, or destructiveHint annotations, and they materially enrich the agent's understanding of side effects.

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

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

The description is dense and efficient, front-loading purpose and determinism before compute semantics, data handling, and export behavior. Minor redundancy ('OpenChainGraph compute node' appears twice in the first two sentences) and the inline URLs add noise, but the overall structure is compact and purposeful.

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 composable attestation tool with no output schema, the description covers compute routing, ephemeral data handling, input hygiene, artifact export with execution_hash, and offline verification — a strong baseline. Gaps remain: the actual attestation logic and policy_parameters field names are deferred to an external manifest, and the output artifact structure beyond execution_hash is unspecified.

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

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

Input schema coverage is 100%, so the schema already documents all four parameters, including compute enum semantics, parent_hashes execution_hashing references, parent_tool_ids ordering, and policy_parameters as tool-specific input. The description echoes the compute behavior without adding new parameter meaning, keeping this dimension at the baseline for fully-covered schemas.

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

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

The description states a clear verb and resource: an OpenChainGraph compute node performing an attestation related to bulk disbursement integrity, exporting an AP2 artifact. It positions the tool as a deterministic attestation compute node, which distinguishes it from the broader sibling set. However, it never explains what 'bulk disbursement integrity' actually verifies or what claim the attestation makes, leaving the core semantic to inference.

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 concrete guidance on how to use the tool: compute mode routing (server-side vs. browser delegation for gpu:true nodes) and the notable constraint 'Use synthetic or anonymised inputs only.' It does not state when to use this tool versus alternative attest_* siblings, nor any when-not-to-use conditions, so the guidance is operational rather than selective.

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 discloses that inputs are transient and not stored, logged, or retained. It also explains the deterministic nature, the compute binding behavior, and the export artifact with execution_hash. This provides excellent transparency 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 somewhat verbose, containing URLs and technical details, but it is well-structured. It starts with a title, then explains the core concept, compute modes, input handling, and outputs. While dense, it avoids redundancy and each sentence adds information. A score of 4 reflects a balance between thoroughness and conciseness.

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

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

The description covers all key aspects: the tool's role, compute behavior, input handling, output artifact, and even a usage constraint (synthetic inputs). Given the complexity of the parameters and the existence of an output schema, the description is sufficiently complete for an agent to understand when and how to invoke it.

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

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

The input schema already covers all parameters with 100% coverage. The description adds meaningful context for the compute parameter, explaining the default behavior and delegation logic. It also hints at policy_parameters via the manifest reference, but does not elaborate further. Since schema coverage is high, a score of 4 is appropriate for the added 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 clearly states the tool's purpose: to attest calculation-agent independence via an OpenChainGraph compute node. It specifies the verb 'attest' and the resource, and distinguishes itself by mentioning attestation_mandate and AP2 artifact export with execution_hash for provenance. This is specific enough to differentiate from the many sibling tools.

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

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

The description provides usage guidance for compute modes (auto/server/browser) and explicitly instructs to use only synthetic or anonymised inputs. It explains conditions for server-side vs browser delegation (gpu:false vs gpu:true nodes). However, it does not explicitly state when to prefer this tool over its many alternatives, but the specific attestation focus gives enough 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?

The description adds substantial context beyond the annotations: determinism, server-side compute on Cloudflare Workers, browser delegation, transient processing with no storage/logging/retention, AP2 artifact export with execution_hash, and FV-status snapshot semantics. This is rich behavioral disclosure, and it does not contradict the readOnly, idempotent, or non-destructive 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 description is dense but purposeful, front-loading the tool identity and then covering compute modes, data handling, artifact export, and verification status. Some clauses, such as the FV-status snapshot explanation, are verbose, but they contribute meaningful operational context for a complex 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?

The description explains compute behavior, transient input handling, artifact export, and verification status, which covers much of the operational context. However, without an output schema, it does not fully describe the return structure, and it defers policy_parameters field names to a manifest that is not provided. It also does not explain what the daily reconciliation attestation certifies.

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

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

Schema coverage is 100%, so the input schema already documents all four parameters. The description adds useful compute-mode context, especially around server vs. browser execution, but it mostly reiterates the compute enum semantics rather than adding deeper meaning to parent_hashes, parent_tool_ids, or 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 description identifies a deterministic OpenChainGraph compute node that attests daily reconciliation and exports an AP2 artifact with execution_hash for chain provenance. This is clear enough as an attestation/provenance operation, though it does not distinguish itself from the many attest_* and reconcile_* sibling tools or explain what the daily reconciliation attestation actually validates.

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

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

The description provides detailed compute-mode behavior but no when-to-use guidance versus alternative tools. There is no mention of when this tool should be preferred over siblings like adjudicate_emir_reconciliation or check_safeguarding_reconciliation, and the only usage constraint is the synthetic/anonymised inputs requirement.

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

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

The description adds substantial behavioral context beyond the annotations: inputs are 'processed transiently' and 'not stored, logged, or retained', users are told to use 'synthetic or anonymised inputs only', and the tool is described as deterministic. It also discloses the AP2 artifact export with execution_hash and explains that the FV-status receipt is a snapshot that 'verifies offline'. This goes well beyond the readOnly/idempotent 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 description is dense and covers many aspects, but it contains redundancy: 'OpenChainGraph compute node' appears twice in the first two sentences. The FV-status explanation is lengthy and somewhat tangential. While each sentence carries some information, the structure could be tighter and more 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?

The description covers compute modes, data handling, provenance, and verification, but it leaves important gaps for a complex tool with no output schema. It does not explain the response structure beyond 'AP2 artifact with execution_hash', and it defers policy_parameters field names to an external manifest ('See the tool's manifest for field names'), which is not self-contained. An agent would need additional information to construct valid inputs 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 all four parameters. The description adds some prose about compute mode behavior and parent_hashes chaining, but these largely mirror the schema descriptions. No additional parameter semantics, such as format constraints or examples, are provided beyond what the schema already states.

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

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

The description identifies the tool as an 'OpenChainGraph compute node (attestation_mandate)' for 'Member Margin Call Lifecycle', but it never states a clear verb+resource like 'computes an attestation for the margin call lifecycle'. The purpose is implied through the name and technical framing rather than explicitly described. It also does not differentiate itself from the many sibling 'attest_*' tools beyond the resource 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?

No guidance is given on when to use this tool versus alternatives. The compute mode explanation ('auto', 'server', 'browser') is parameter-level usage guidance, not tool-selection guidance. There are no exclusions, prerequisites, or mentions of sibling tools that might be more appropriate in specific scenarios.

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

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

The description adds substantial behavioral disclosure beyond the annotations: inputs are processed transiently and not stored/logged/retained, an AP2 artifact with execution_hash is exported, compute modes (auto/server/browser) are explained, and a recommendation to use synthetic or anonymised inputs is given. These details go beyond the readOnly/idempotent/destructive hints and provide meaningful 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 description is verbose and includes repeated phrases ('OpenChainGraph compute node' appears twice) and extraneous details like a URL and an FV-status link that may not be necessary for invocation. While it is logically ordered, the length and repetition reduce conciseness, and the most useful information (compute modes) is not front-loaded enough.

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 an auditor tool, the description does not clearly explain the output format of the audit (e.g., conformance report, pass/fail, list of violations). It mentions exporting an AP2 artifact with execution_hash but not what the artifact contains. Given there is no output schema, this is a significant gap for an agent needing to interpret the result.

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

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

Schema coverage is 100%, so each parameter already has a description. The description adds value for the 'compute' parameter by clarifying the default behavior and the 'browser' delegation URL, but does not elaborate on parent_hashes, parent_tool_ids, or policy_parameters beyond what the schema states. Overall it supplements but does not significantly exceed 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 opens with the title and then states it is an 'OpenChainGraph compute node (scheme_rule)' and 'Deterministic OpenChainGraph compute node,' which largely restates the name rather than explaining the audit action. The purpose of auditing ACP/UCP product-feed conformance is implied by the title but never explicitly articulated, leaving an agent to infer what the tool actually 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 guidance is given on when to use this tool versus any sibling audit tools. The description focuses entirely on compute modes, provenance, and security, but never states a use case, prerequisite, or exclusion criteria, so an agent has no help deciding between this and e.g. audit_agent_key_rotation.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true. The description adds valuable context: inputs are transient and not stored/logged/retained, execution is deterministic, and the tool exports an AP2 artifact with execution_hash for chain provenance. Also explains browser delegation instead of server computation. No contradiction with annotations.

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

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

The description is dense and packs in important details like links, FV-status, and execution_hash. But it repeats 'OpenChainGraph compute node' across the first two sentences, and the trailing FV-status/receipt sentence is heavy with hash URLs that could distract from core selection information. It is informative but could be tightened.

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

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

With no output schema, the description compensates by explaining artifact export, browser delegation behavior, and offline-verifiable snapshot. It covers compute semantics, input treatment, and chain provenance. It does not detail what the audit decision output contains, but the artifact+execution_hash description plus the schema are likely sufficient for 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 baseline is 3. The description adds a bit beyond the schema by explaining compute modes ('browser forces client-side execution and returns a browser delegation URL') and transient processing of inputs. But it doesn't clarify parent_hashes/policy_parameters beyond what the schema already gives.

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

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

The description clearly identifies this as an 'Agent Key Rotation Auditor' and an OpenChainGraph compute node with a compliance mandate. It distinguishes the tool's scope by describing its output feed and artifact. However, it does not explicitly state what the audit checks (e.g., rotation compliance rules), so some inference is needed.

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

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

Provides clear execution guidance: compute mode selection ('auto', 'server', 'browser'), server vs. browser delegation semantics, and the explicit instruction 'Use synthetic or anonymised inputs only.' It does not specify when to prefer this tool over sibling auditors, so it falls short of explicit when/when-not 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 and idempotent. The description adds critical context: runs client-side, zero PII, zero network, renders interactive widget. This goes well beyond annotations, providing full disclosure of 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?

Two densely informative sentences with no wasted words. Front-loaded with the purpose, then usage, then behavioral details. Perfect structure.

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?

Covers purpose, usage, behavioral traits, and parameter semantics. Output schema exists so return values need not be described. A minor gap: the term 'AINumbers tool' is not explained, but given the sibling 'list_ainumbers_tools', it's likely known. Overall very complete.

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

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

Schema coverage is 100%; baseline 3. The description adds meaning by explaining that inputs come from the manifest input_schema and are applied via AIN Bridge prefill, clarifying the parameter's role beyond the schema description.

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

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

The description states specific RFC validations (9728, 8707) and risk assessment (token-passthrough/confused-deputy), clearly distinguishing it from siblings like 'audit_mcp_tool_scope_revocation' and '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?

Explicitly states 'Use when a developer is securing an MCP server's authorization,' providing clear context. Could be stronger by explicitly noting when not to use it or comparing to related siblings, but the guidance is effective.

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

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

The description goes beyond annotations by disclosing that inputs are processed transiently and not stored, logged, or retained, and that synthetic or anonymised inputs should be used. It also details compute behavior (server-side vs browser delegation) and mentions exporting an AP2 artifact with execution_hash for provenance. This is additional context beyond the readOnly/idempotent hints, and no contradictions with the annotations are present.

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 overly long and includes many non-essential details such as the URL and FV-status hash, which are irrelevant to actually calling the tool. It is not front-loaded with the core purpose; instead, it dives into compute binding and provenance, making it harder for an agent to quickly extract the essential usage 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?

Despite a verbose description, it lacks a clear explanation of what the tool actually does (what 'scope revocation' means, what the decision function evaluates). With no output schema, the agent is left uncertain about the return format beyond the mention of an AP2 artifact. It does not explain how policy_parameters should be formed or what constitutes valid input, leaving the tool under-specified for a complex audit function.

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

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

The input schema already provides full descriptions for all four parameters (100% coverage), so the baseline is 3. The description does not add any meaning beyond the schema; it merely repeats the compute-mode explanation in prose. It does not clarify the semantics of parent_hashes or policy_parameters beyond what the schema already states.

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

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

The title and description state it is a 'MCP Tool Scope & Revocation Auditor' and an 'OpenChainGraph compute node', but the description never explains what 'scope revocation' auditing actually entails or what decision function it computes. It focuses on compute modes and provenance rather than the core purpose, leaving the agent to infer its function from the name alone. It does not distinguish itself from the many other audit/validate siblings, such as audit_mcp_oauth or validate_mcp_server_identity.

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 guidance on when to use this tool versus alternatives. The description mentions compute modes and FV-status but provides no context about when a user should select this auditor over other audit tools. There is no mention of exclusions, prerequisites, or alternative 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 declare readOnlyHint=true and idempotentHint=true. The description adds valuable behavioral context: browser-based, client-side only, zero PII, zero network, and renders the AINumbers widget. This goes beyond annotations and fully discloses execution environment and privacy characteristics.

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 two sentences long, front-loaded with purpose and dimensions, and each sentence earns its place. No filler or redundancy.

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

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

Despite the tool's complexity (10 dimensions, weighting matrix, client-side execution), the description covers purpose, dimensions, output (weighted comparison matrix and Markdown memo), execution environment, privacy, and integration details. With an output schema present, the description is fully adequate.

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% for the single parameter 'inputs', with a description that explains it is a map of input element IDs to values. The tool description adds context about how inputs are applied via AIN Bridge prefill, which enhances understanding of the parameter's role.

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 'Score and compare BaaS providers across 10 capability dimensions' with a specific verb ('score and compare') and resource ('BaaS providers'). It distinguishes from sibling tools implicitly as the only BaaS-specific comparator among many general comparison tools.

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

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

The description implicitly indicates when to use (when comparing BaaS providers) but does not explicitly exclude alternatives or provide context for when not to use it. The context is clear but lacks exclusions or comparisons to similar 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?

Even though annotations already mark the tool as read-only, idempotent, and non-destructive, the description adds substantial behavior beyond those hints: inputs are processed transiently and not stored, logged, or retained; browser delegation URLs are returned in certain modes; an AP2 artifact with execution_hash is exported; and provenance/FV-status details are given. This materially helps an agent understand side effects and trust properties.

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

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

The description is dense and front-loads important execution and privacy facts, but it repeats 'OpenChainGraph compute node' and includes a long FV-status receipt explanation that is not necessary for tool selection or invocation. Most sentences earn their place, but the overall structure is 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?

There is no output schema, and the description does not explain the shape or meaning of the benchmark result, nor how policy_parameters should be structured. Execution, privacy, and provenance details are thorough, but the core computational contract—what inputs are needed and what output is returned—remains 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 coverage is 100%, so the baseline applies. The description mostly restates compute-mode semantics already present in the schema, though it adds one useful provenance clue by naming upstream artifact art-472-cbcr-builder, which helps populate parent_hashes. It does not compensate for the opaque policy_parameters object, whose fields remain 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 title and opening line identify the domain (transfer-pricing interquartile range benchmark) and state that it is a deterministic OpenChainGraph compute node, but the description never explains what computation is actually performed or what the benchmark result means. It reads more like infrastructure and compliance metadata than a functional 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?

The description gives operational guidance: compute modes (auto/server/browser), gpu:true delegation, restricted input types such as 'Use synthetic or anonymised inputs only', and an upstream dependency on art-472-cbcr-builder. However, it never states when to prefer this tool over alternatives or when it should not be used, leaving usage mostly implied by 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?

The description says inputs are processed transiently and not stored, logged, or retained - this is significant behavioral disclosure. It also mentions exporting an AP2 artifact with execution_hash, which is beyond annotations. Annotations already include readOnlyHint:true, idempotentHint:true, destructiveHint:false, and the description aligns with these. No contradiction. It could add details on security/auth, but given annotations, this is sufficient.

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 overly lengthy and includes extraneous information like the exact URL and FV-status JSON hash, which may not be essential for an agent to call the tool. It front-loads the compute mode logic but then has a long tail of provenance details. Could be more concise and focused on actionable 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?

Given the tool's complexity with compute modes, upstream dependencies, and artifact export, the description covers most operational aspects. It mentions the upstream artifact, compute decisions, and output artifact. However, it lacks info on rate limits or error handling, but those are not common in this context. It's nearly complete for an agent to invoke 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 documents all parameters. The description adds context on compute modes and how policy_parameters are used, which goes beyond the schema. However, it doesn't explain the exact expected structure of policy_parameters beyond 'see manifest', but that's a gap the schema can't fill either. Overall, adds good 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 clearly identifies the tool as a compute node for agreement acceptance binding, with specific verb 'bind' and resource 'agreement acceptance'. It distinguishes from siblings by specifying it consumes upstream artifacts from art-276-mutual-nda-composer, which is a differentiator. However, it is somewhat verbose and the core purpose could be stated more directly.

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 modes and when each is used, particularly distinguish 'auto' vs 'browser' and gpu:true nodes. It implies use cases for chaining with parent_hashes. However, it doesn't explicitly state when NOT to use this tool or compare it to alternatives like other 'bind_*' siblings. The context of consuming from a specific upstream gives some 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?

The description is transparent about the behavior: inputs are processed transiently and not stored, logged, or retained. It also explicitly notes that only synthetic or anonymised inputs should be used)Skip, which is important for data handling. While the descriptions of the compute modes (auto, browser delegation URL) cover some behaviors, they indeed seem to duplicate what's in the schema's extensive descriptions. The non-retention guarantee and the deliberate input guidance go beyond the schema, which is valuable.

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

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

The description is a single dense paragraph that gets to the point quickly. It explains compute modes with concrete examples Serious errors: the gpu:true case is implied rather than stated, and the URL is included but not hyperlinked. Some information like 'Deterministic OpenChainGraph compute node' is repeated across sentences. Overall it's reasonably sized and organized, with a few redundancies.

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

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

The description explains the compute modes, the transient nature of inputs, the purpose (exporting an AP2 artifact for chain provenance), and links to a reference. Given the complexity of the compute node with multiple modeshare and security considerations, this provides solid contextual coverage. A bit more detail on what 'attested subject' means would help complete the picture.

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?

Description adds substantial meaning to parameters. For 'compute', it clarifies the default ('auto'), the condition governing it (gpu:false nodes with registered kernel), and the browser delegation behavior. For 'policy_parameters', it states these are computed server-side and instructs to use synthetic or anonymized data. This meaningfully supplements the schema, which only says 'Input parameters for this node's decision function'.

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

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

The description does not explicitly state what the tool does. It vaguely hints at 'bind an attested artifact subject', but there is no direct explanation of its purpose. The title, 'Attested Artifact Subject Binder', is also unclear. It is better than a tautology, but still requires the user to infer the tool's functionality from its name and context.

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

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

The description provides some usage guidance by explaining the compute modes (auto, server, browser) and the transient processing of inputs humanos. However, it does not explicitly clarify when to use 'auto' versus 'server' versus 'browser' beyond the schema defaults, nor does it discuss alternatives or the circumstances under which one mode would be preferred over another.

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

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

The description adds behavioral context beyond annotations: determinism, transient processing with no storage/logging/retention, browser delegation URL behavior, and the FV-status receipt verification mechanism. It explains the execution_hash export for chain provenance. Since annotations already declare readOnlyHint=true and idempotentHint=true, the description enriches the behavioral model without contradicting it.

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 information-dense but somewhat sprawling: combining compute behavior, gpu delegation rules, transient processing, FV-status verification, artifact consumption, and an open URL. The compute-mode behavior is front-loaded, but the FV-status verification details feel tangential and could be shortened. The first sentence is short and clear, but the third sentence over-packs logistics into one long string.

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 with nested policy_parameters object and no output schema, the description covers compute modes, gpu delegation, chain provenance via parent_hashes, artifact consumption, and retention guarantees. It explains the export behavior (AP2 artifact with execution_hash). It's largely complete for an agent to call correctly given the schema already documents parameters — though it doesn't describe the browser delegation URL return format in detail.

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

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

Schema coverage is 100%, so the schema already documents all four parameters. The description adds high-level context about compute modes (server-side vs browser delegation) that complements the schema's enum descriptions. It notes policy_parameters are computed server-side for gpu:false nodes with registered kernels, which adds meaning beyond the schema's placeholder 'see the tool's manifest for field names' — so description adds marginal but real 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 states a specific verb and resource: builds a 226J Response Evidence Pack as an OpenChainGraph compute node. It clearly identifies the tool's role (compliance_mandate) and distinguishes it from generic evidence builders by naming the specific artifact and chain. However, it doesn't explicitly contrast with sibling tools like build_evidence_pack or assemble_ocg_evidence_bundle, so it relies on the domain-specific context for differentiation rather than explicit sibling naming.

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

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

The description provides clear guidance on compute modes (auto/server/browser) with explicit conditions for when each applies, and explains gpu:true always delegates to browser. It specifies that inputs are processed transiently and not stored, and instructs to use synthetic or anonymised inputs only. However, it doesn't tell when to choose this specific pack builder over sibling evidence pack tools, though the specificity of the 226J context implies 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 readOnlyHint, idempotentHint, and destructiveHint=false. The description adds genuinely useful behavioral context beyond that: deterministic execution, transient non-retained input processing, server vs. browser delegation behavior, and the AP2 artifact/execution_hash chain-provenance contract. No contradiction with annotations.

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

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

The description is dense and front-loaded with purpose, but it repeats 'OpenChainGraph compute node' twice and buries useful guidance among URL/hash/FV-status metadata that could live in structured fields. It is informative but every sentence 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?

Given no output schema, the description compensates by describing the output (AP2 artifact with execution_hash), the downstream consumer, and the offline FV-status verification mechanism. Gaps remain: the exact response shape is undisclosed, and policy_parameters field names are deferred to an external manifest rather than enumerated.

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 earns a 4 by enriching the compute parameter semantics (default auto behavior, gpu:true always delegates, browser returns delegation URL) beyond what the enum lists, and by clarifying that policy_parameters feed a decision function computed server-side.

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

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

States a specific action (build) applied to a specific resource (adverse action notice), and positions it as an OpenChainGraph compute node for the compliance_mandate. Names its downstream consumer (art-227-validate-adverse-action-notice), which differentiates it from the sibling validate_adverse_action_notice without needing to open the schema.

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

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

Implies usage context through the build→validate pipeline and gives a hard constraint ('Use synthetic or anonymised inputs only'). However, it never explicitly states when to choose this tool over validate_adverse_action_notice or other build_* siblings, nor does it give any when-not-to-use 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?

The description provides substantial behavioral context beyond the annotations: it states that inputs are processed transiently and not stored, logged, or retained, and explicitly instructs to use synthetic or anonymised inputs only. It clarifies deterministic behavior and explains the compute delegation logic (gpu:false vs gpu:true, browser URL return). These details are not present in the annotations (readOnlyHint, idempotentHint, destructiveHint) and meaningfully inform agent behavior, adding significant value.

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 overly long and includes extraneous elements such as a URL ('Open at: https://ainumbers.co/chaingraph/art-379-agent-incident-record-composer.html') and a JSON verification status path with a note about snapshots and offline verification. These do not aid tool selection or invocation and inflate the length. The core information (compute modes, transient processing, artifact export) is buried among these details, and the description is not front-loaded with the most critical usage 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?

The description covers compute modes, data handling, and the artifact export with execution_hash, which are valuable for correctness. However, it lacks a description of the output artifact's structure or content (no output schema is present), and it refers to the tool's manifest for policy_parameters field names rather than providing them. For a tool with nested objects and no output schema, the description should explain what the returned AP2 artifact contains and clarify what an 'incident record' encompasses. These gaps make the description incomplete for a complex tool, though it does address several critical usage aspects.

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 each parameter already documented in detail (compute enum, parent_hashes, parent_tool_ids, policy_parameters). The description adds minimal new semantic value beyond the schema—it reiterates compute mode behavior and notes that policy_parameters are computed server-side when applicable, but these points are already reflected in the parameter descriptions. With full schema coverage, the baseline of 3 is appropriate; the description does not introduce syntax or format details absent from 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 identifies the tool as an 'Agent Incident Record Composer' that acts as an OpenChainGraph compute node and exports an AP2 artifact with execution_hash. It states the verb (build/compose) and resource (incident record), and the title matches the name. However, it does not clearly define what an incident record contains or how it differs from other build_* tools beyond the name; the purpose is inferred from the name and the compliance_mandate hint rather than explicitly 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 implies usage for composing incident records under a compliance mandate, and explains compute modes (auto/server/browser) and their implications. However, it does not explicitly state when to use this tool versus alternatives, nor does it provide any exclusion criteria or refer to sibling tools. The usage guidance is implied through the compliance_mandate label and the compute mode explanation, but there is no direct 'use this when' statement.

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 include readOnlyHint: true and idempotentHint: true. The description adds the critical detail that inputs are not stored or logged, and specifically warns to use synthetic/anonymised inputs. It also mentions the execution_hash for provenance and the FV-status snapshot, going beyond annotation coverage.

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