AINumbers Fintech Intelligence Suite

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

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

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

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

Four tight sentences front-loading purpose, scope, behavior, and exclusions. Every sentence delivers key information without redundancy.

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

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

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

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

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

Single parameter 'credential' is described as ACDC/vLEI JSON object with expected subfields (v, d, i, ri, s, a, e, r). Schema coverage 100%, but description adds meaning about how these fields are processed (SAID recomputation, schema cross-check), which is not in the schema.

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

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

The description clearly states it recomputes SAIDs of ACDC/vLEI credentials under specific derivation codes and cross-checks schema SAID against a pinned table. It distinguishes this as a structural integrity check separate from trust/authority/revocation tools.

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

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

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

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

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

Annotations already cover readOnly/idempotent/non-destructive/closed-world, but the description adds genuinely useful behavior: compute modes (auto/server/browser), browser delegation, transient processing with no storage or logging, the 'synthetic or anonymised inputs only' constraint, and an AP2 export carrying execution_hash. Retention and data-handling disclosure goes beyond the structured fields. It still omits what the decision function returns or any failure/rejection 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?

Roughly 180 words where the domain-relevant content is a single clause; the remainder is ChainGraph platform boilerplate about kernels, delegation URLs, and FV-status receipt hashes. It is not front-loaded toward the tool's actual function, and most sentences do not earn their place for an agent deciding whether to call 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?

An output schema exists, so return values need not be explained, and the compute/privacy/provenance aspects are covered. What is missing is domain completeness: a tool whose inputs are an opaque policy_parameters bag should say what the adjudication decision is and what those parameters represent, given the deep sibling set it must be disambiguated from.

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

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

Schema description coverage is 100%, so the schema already documents compute, parent_hashes, parent_tool_ids, and policy_parameters. The description only restates the compute mode semantics, which duplicates the enum's own description, and adds nothing about how parent hashes chain or which policy_parameters fields matter. Baseline 3 for high schema coverage.

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

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

The title and opening line name a specific verb+resource (adjudicating EMIR trade-repository reconciliation breaks), so the domain is identifiable. However, the body never explains what 'adjudication' decides, and nothing distinguishes it from close siblings such as reconcile_emir_pairing, age_emir_reconciliation_breaks, or validate_emir_trade_report. The rest of the text is generic platform boilerplate rather than purpose.

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

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

There is no statement of when to use this tool versus the many other EMIR reconciliation tools. The only routing hint is 'Output feeds: art-483-emir-break-ageing', which describes downstream consumption, not when an agent should select this tool over alternatives. Prerequisites and exclusions are absent.

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

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

Annotations already cover the read-only/idempotent/non-destructive profile, and the description adds genuinely new behavioral context: inputs are processed transiently and not stored or logged, compute modes (auto/server/browser) determine server-side vs browser delegation, gpu:true nodes always delegate, and the node exports an AP2 artifact carrying execution_hash for provenance. It stops short of explaining determinism caveats or the execution_hash verification path in concrete terms.

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

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

The text is long and boilerplate-heavy, with near-duplication ('OpenChainGraph compute node (attestation_mandate). Deterministic OpenChainGraph compute node.'), restatement of compute-mode semantics that the schema already carries, and a long FV-status URL/receipt sentence. The core purpose sentence is buried under platform metadata rather than front-loaded.

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

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

With an output schema present the description need not explain return values, and annotations cover safety. But for a 4-parameter node with a nested free-form policy_parameters object, the description never states what decision function is being run or what ageing semantics apply, leaving the agent dependent on external manifest/URL content it cannot fetch.

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

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

Schema description coverage is 100%, so all four parameters (compute, parent_hashes, parent_tool_ids, policy_parameters) are already documented in the schema. The description largely restates the compute-binding semantics already present in the enum description and adds nothing about policy_parameters field names — it explicitly defers to 'the tool's manifest'. Baseline 3 applies.

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

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

The title and first line give a specific verb+resource (ageing of EMIR reconciliation breaks), which is more than a tautology. However, the body never explains what 'ageing' produces (bucket scheme, days-past-due logic, output shape) and offers no differentiation from close siblings such as reconcile_emir_pairing, adjudicate_emir_reconciliation, or check_emir_uti_completeness, so an agent cannot tell exactly which EMIR break tool to pick.

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 / when-not-to-use guidance and no routing to alternatives; the sibling set is dense with overlapping EMIR reconciliation tools. The only usage constraint given is 'Use synthetic or anonymised inputs only', which is a data-handling caveat rather than selection guidance.

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

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

Annotations already 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?

Annotations already declare readOnly, idempotent, non-destructive and closed-world, but the description adds genuinely new behavior: transient processing with no storage/logging/retention, browser delegation semantics, and emission of an AP2 artifact with execution_hash for provenance. These go beyond what the annotations convey and are consistent with 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 purpose is front-loaded but the text is padded with repeated self-labeling ('OpenChainGraph compute node' appears twice) and a long offline-receipt aside about the FV-status file. Several sentences could be trimmed without losing information.

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

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

With an output schema present, return values need not be described, and the description still covers compute modes, input-handling constraints, provenance chaining and upstream/downstream artifact links. Only the actual decision semantics of policy_parameters remain implicit.

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 fully documents compute, parent_hashes, parent_tool_ids and policy_parameters. The description's compute-mode explanation merely restates the schema and adds no new parameter meaning, so the baseline 3 applies.

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

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

The name and title convey a specific verb+resource (aggregating CBAM precursor emissions), but the description itself mostly explains OpenChainGraph compute mechanics rather than what the aggregation computes. It never distinguishes this tool from close siblings like calculate_cbam_embedded_emissions or model_cbam_certificate_cost.

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

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

There is no guidance on when to choose this tool over alternatives; the compute auto/server/browser discussion is a rendering preference, not a selection criterion between tools. The only real usage instruction is 'use synthetic or anonymised inputs only,' which is a constraint rather than a when-to-use rule.

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

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

Annotations already declare readOnly/idempotent/non-destructive/closed-world, so the safety profile is covered. The description adds genuinely useful context beyond that: inputs are processed transiently and not stored/logged/retained, 'use synthetic or anonymised inputs only,' and compute-mode delegation behavior (server vs browser, gpu:true always delegates). This is meaningful behavioral disclosure a caller could not get from the annotations.

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

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

The compute-mode and privacy content is front-loaded usefully, but the body is dense with pipeline plumbing and ends in a verbose FV-status URL plus a long hex hash that consume space without helping an agent invoke the tool. Several sentences 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?

An output schema exists and annotations cover safety, so those burdens are relieved. However, the core aggregation semantics are never explained and policy_parameters content is deferred to an external 'manifest' rather than described, leaving a gap for a compute tool with a nested free-form object.

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

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

Schema description coverage is 100%, so the schema already documents compute, parent_hashes, parent_tool_ids, and policy_parameters. The description's compute-mode and execution_hash explanations largely duplicate what the schema already says and add no new syntax or format detail. Baseline 3 applies when the schema does the heavy lifting.

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

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

The description restates the title ('Agent-Action Audit-Trail Aggregator: OpenChainGraph compute node') and calls itself a 'Deterministic OpenChainGraph compute node,' but never states plainly what it does with the receipts it aggregates or what the aggregation produces beyond 'exports an AP2 artifact with execution_hash.' The verb+resource is only inferable from the tool name, not the description text.

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 lists upstream artifacts it consumes and the downstream tool its output feeds ('ptg-01-ap2-prompt-template-generator'), which hints at pipeline position, but it gives no explicit when-to-use guidance, no conditions, and no alternatives among the many sibling aggregators/validators. The agent must infer usage from the artifact lineage.

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

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

Annotations already cover the readOnly/idempotent/non-destructive safety profile, but the description adds genuinely useful behavior: deterministic server-side vs browser-delegation compute modes, transient processing with no storage/logging/retention, and an AP2 artifact carrying execution_hash for provenance. This goes well beyond the structured hints.

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

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

The text is bloated with redundancy ('OpenChainGraph compute node' stated twice), receipt/URL boilerplate, and FV-status prose that does not help an agent select or invoke the tool. The functional statement is buried rather than front-loaded.

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

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

For a 4-parameter node with nested objects and an output schema, the description supplies the important missing context: chaining inputs/outputs, data-retention policy, and provenance export. Return values are rightly left to the output schema.

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

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

Schema description coverage is 100%, so the baseline is 3. The description only restates the compute-mode behavior already documented in the schema and defers policy_parameters to 'the tool's manifest', adding no new parameter semantics.

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

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

The description states a specific verb and resource — aggregating the ownership 50%-rule as a deterministic OpenChainGraph compute node within the compliance_mandate class. An agent can identify the function, though it is wrapped in template boilerplate and never explicitly contrasts itself with sibling aggregate_* tools.

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

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

It gives concrete chaining context (consumes art-90-sanctions-screening-fit-diagnostic, feeds art-92 and cry-05), which implies where it fits in a pipeline. However, there is no explicit when-to-use/when-not or alternative-selection guidance for an agent choosing between 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 cover the safety profile (readOnly, idempotent, non-destructive, closed-world), so the bar is lower. The description adds real behavioral context beyond them: inputs are processed transiently and not stored/logged/retained, browser delegation occurs for compute:'browser' and gpu:true nodes, and an AP2 artifact with execution_hash is exported for chain provenance.

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

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

A single dense run-on spanning compute modes, data handling, chain provenance, an external URL and a 64-character hex FV-status path. The hash/filename and 'a snapshot, not a subscription' clause consume significant space without helping an agent decide to call or invoke the tool.

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

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

With an output schema present, return-value explanation is unnecessary, and the description does cover compute delegation, data retention, and provenance export. However, for a 4-parameter aggregation node it never explains what is being aggregated or what policy_parameters should contain, leaving the core 'what am I computing' question unresolved.

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's compute-mode text largely duplicates the 'compute' parameter's own schema description, and it adds no field-level meaning for policy_parameters beyond referring to the 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 opening two sentences ('Provable Reputation Score Aggregator: OpenChainGraph compute node (attestation_mandate). Deterministic OpenChainGraph compute node.') essentially restate the name and title without saying what reputation score is being aggregated from which inputs. Nothing distinguishes it from the dozens of other '*_compute node' siblings (aggregate_solvency2_scr_modules, aggregate_execution_receipts, etc.); the differentiating information is buried in an infra/URL 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 only usage instruction is the constraint 'Use synthetic or anonymised inputs only.' There is no statement of when to call this tool versus sibling aggregators, no prerequisites, and no routing guidance beyond the compute-mode mechanics that are already in the schema.

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

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

Annotations already declare readOnly/idempotent/non-destructive, and the description adds substantial context beyond them: transient processing with no logging or retention, a synthetic-inputs-only constraint, the AP2 artifact with execution_hash for provenance, and the browser-delegation fallback. This is meaningful behavioral disclosure. It stops short of 5 because return/pagination behavior and failure modes are unaddressed.

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 front matter opens with infrastructure boilerplate rather than the tool's job, and the closing FV-status sentence embeds a 64-character hash path with a snapshot/subscription caveat that is mostly noise for tool selection. The compute-mode details and privacy statement earn their place; the URL/hash tail does not.

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

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

An output schema and annotations exist, so safety and return shape are covered externally. Still, the core decision-function inputs (policy_parameters) are punted to an external manifest, and the description never explains what 'modules' are being aggregated, leaving a gap for a fairly complex chained computation node.

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

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

Schema description coverage is 100%, so the schema already documents compute, parent_hashes, parent_tool_ids and policy_parameters in detail. The description restates the compute-mode semantics but adds nothing about the chaining parameters and explicitly defers policy_parameters fields to 'the tool's manifest'. 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 convey that this aggregates Solvency II SCR standard-formula modules, but the description body itself spends most of its text on OpenChainGraph compute-node mechanics rather than stating what the aggregation does or what inputs it consumes. A sibling like calculate_solvency2_scr_ratio is not distinguished from this one, so the agent must infer the boundary. Purpose is discernible but not carried by the description.

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

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

The description gives real usage guidance for the compute parameter (when to use auto/server/browser) and names a downstream consumer ('Output feeds: art-180-solvency2-scr-ratio-calculator'). However it never says when to choose this tool over the sibling SCR ratio calculator or when aggregation is warranted versus a direct calculation.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false, and closed-world, so the safety profile is covered. The description adds genuinely useful behavioral context beyond that: deterministic computation, transient processing with no storage/logging/retention, and the fact that it exports an AP2 provenance artifact with execution_hash for chaining.

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 core operational facts are front-loaded, but the paragraph is dense with proprietary jargon and closes with a verbose FV-status/receipt sentence that reads as boilerplate rather than task-relevant guidance. Several clauses could be trimmed without loss.

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 compensate by naming the output artifact type and its downstream consumer, and it covers data-handling and compute modes. But the actual decision function inputs are deferred to 'the tool's manifest,' leaving the aggregation semantics and return payload shape under-specified.

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

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

Schema description coverage is 100%, so the schema already documents compute, parent_hashes, parent_tool_ids, and policy_parameters in detail. The description repeats the compute-mode semantics and adds no new per-parameter meaning, so the baseline 3 applies.

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

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

The description identifies the tool as an OpenChainGraph compute node and states it exports an AP2 artifact with execution_hash feeding art-620-summa-mst-inclusion-checker. However, what the aggregation actually computes ('Summa MST liabilities') is only implied by the title/name and never explained, so the agent gets the plumbing but not the 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?

It gives compute-mode guidance (auto/server/browser, browser delegation) which is mostly restated in the schema, and a data-handling warning about synthetic inputs. But there is no when-to-use-vs-alternative guidance, no prerequisites, and no indication of when this aggregation is appropriate versus the many sibling aggregators.

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

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

Annotations already declare readOnly, idempotent, non-destructive, closed-world, but the description adds real operational context: transient processing with no storage/logging/retention, synthetic-inputs-only guidance, server vs browser delegation semantics, and an AP2 export carrying execution_hash for provenance. This goes meaningfully beyond the annotations, though the compute-mode text partly duplicates the schema.

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

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

Front-loaded with the title, but the body is one dense run-on paragraph that repeats 'OpenChainGraph compute node' twice and embeds a raw FV-status hash URL. The core purpose is buried under infrastructure boilerplate.

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

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

With annotations and an output schema present, the safety profile and return shape are covered, and the description supplies provenance (upstream/downstream artifacts), compute-mode behavior, and data-retention policy. What is missing is the substantive KPI/GAR computation semantics, which the manifest reference leaves unresolved.

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 little parameter detail beyond the schema; notably it says to consult 'the tool's manifest' for policy_parameters field names, which leaves the most important inputs opaque rather than compensating.

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

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

The title names a specific aggregation (Taxonomy KPI & Green Asset Ratio) and the description scopes it as a model_governance compute node with named upstream (art-73-taxonomy-alignment-scorer) and downstream (cry-05-...) artifacts. However, the body text is almost entirely infrastructure boilerplate and never states what the aggregation actually computes or what a GAR result means, so the operation itself is only inferable from the title.

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

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

The chain position (consumes art-73, feeds cry-05) implies when this node belongs in a workflow, and the compute modes hint at execution context. But there is no explicit when-to-use vs alternatives and no conditions/exclusions, so an agent must infer placement from the artifact graph.

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

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

Annotations already declare readOnly, idempotent, non-destructive and non-open-world, so the safety profile is covered; the description adds genuinely non-obvious behavior: inputs are processed transiently and not stored or logged, browser mode returns a delegation URL instead of computing, and an AP2 artifact with execution_hash is exported for provenance. That is real added context beyond the annotations, though it does not describe response shape or failure modes.

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

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

The functional statement is front-loaded, but the body is padded with infrastructure boilerplate and a long FV-status sentence ending in a raw 64-hex receipt hash that contributes little to tool selection or invocation. Several clauses duplicate the schema's compute description. The text is readable but not tight.

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

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

An output schema exists, so return values need not be spelled out, and all four parameters are schema-documented. What is missing is the substance of the decision function: policy_parameters accepts arbitrary keys and the description defers field names to an external manifest, so an agent cannot construct a meaningful call from the definition alone. The upstream/downstream chain and doc link partly compensate.

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

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

Schema description coverage is 100%, so compute, parent_hashes, parent_tool_ids and policy_parameters are already documented in the schema; the description's compute-mode text largely repeats the schema's own enum description. It does add the chaining intent via 'Consumes upstream artifacts from...', but policy_parameters field names are punted ('See the tool's manifest for field names') rather than clarified. Baseline 3 applies when the schema carries the weight.

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+resource ('IHB Interest Allocation') and frames it as a deterministic OpenChainGraph compute node in the analytics_mandate family, which differentiates it from sibling compute tools. It also names the upstream artifacts it consumes (art-259-compute-multilateral-netting, art-262-validate-ebam-acmt-flow), tying it to real siblings. However, it never explains what the IHB interest allocation decision actually computes, leaving the semantic purpose to the name.

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

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

It gives explicit when-conditions for the compute mode (auto/server/browser, gpu:true always delegates), which is useful operational guidance. But it never says when an agent should choose this tool over alternative compute or allocation tools, nor any prerequisites beyond the upstream artifacts consumed. Usage is implied by the chain context rather than stated.

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

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

Annotations already declare read-only, idempotent, non-destructive, closed-world behavior, so the bar is lower — yet the description adds real value beyond them: transient input processing with no storage/logging/retention, deterministic execution, browser-delegation URL returned for gpu:true or compute:'browser', and an exported AP2 artifact carrying execution_hash for provenance. That is substantive behavioral disclosure for a compute node.

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

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

The text is front-loaded reasonably (name/label first) but bloated: the trailing FV-status snapshot clause with a 64-character hash and the 'not a subscription; verifies offline regardless' aside consume space without helping an agent decide or invoke. Several sentences describe the OpenChainGraph platform rather than this tool, diluting the signal.

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

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

An output schema exists, so return values need not be explained, and the description covers chaining, compute modes and privacy. But for a compliance compute node with a nested policy_parameters object it never states which policy fields are expected, and it never describes what the amortization actually produces or its governing assumptions — the agent must consult an external manifest.

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

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

Schema description coverage is 100% and the four parameters are already fully documented in the schema, so the baseline is 3. The description echoes the compute-mode semantics that the schema already defines and says nothing about the contents of policy_parameters beyond 'See the tool's manifest', adding no meaning 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 restates the title ('ASC 340-40 Commission Amortization') and labels the tool a 'compute node (compliance_mandate)', but never says in plain terms what it computes — e.g. that it builds a capitalized commission amortization schedule from reconciled commission data. It does distinguish itself contextually by naming its upstream artifact (art-266-reconcile-commission-statement), which hints at its role in a chain, but the core verb+resource statement is largely tautological.

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 meaningful operational guidance: compute mode semantics (auto/server/browser), the 'synthetic or anonymised inputs only' restriction, and the note that it consumes upstream artifact art-266. However, nothing says when to use this tool versus the many sibling amortization/build-schedule tools, nor any prerequisites for ordering it in a chain.

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

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

Annotations already declare readOnly/idempotent/non-destructive, but the description adds real behavioral context beyond them: deterministic execution, transient processing with no storage/logging/retention, server-vs-browser compute routing, and an exported AP2 artifact carrying execution_hash for chain provenance. That is meaningful disclosure for a compute node.

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

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

It is front-loaded with the tool's name but immediately front-loads low-value compute-binding plumbing that is also in the schema. The trailing artifact URL and FV-status hash receipt are tangential to tool selection, adding bulk without helping an agent decide or invoke.

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

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

An output schema exists, so return values need no explanation, and annotations cover the safety profile. The description is complete on execution mechanics and provenance but omits the domain semantics of the DC-vs-LC analysis and what fields policy_parameters expects (it defers to 'the tool's manifest'). Adequate but with a real gap.

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

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

Schema description coverage is 100%, so the schema already documents compute, parent_hashes, parent_tool_ids, and policy_parameters. The description's explanation of compute modes duplicates the schema's own enum description and adds nothing about what belongs in policy_parameters. Baseline 3 applies.

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

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

The name and title state a concrete verb and resource (cost-benefit analysis of documentary collection vs letter of credit), but the description itself only restates the title in the first clause and then pivots to OpenChainGraph compute-node boilerplate. It never explains what the analysis produces or how it differs from siblings like compute_ltc_funding_comparator or compare_receivables_finance_economics. Purpose is inferable from the name, not from the prose.

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 statement and no routing to an alternative sibling. The only situational advice is 'Use synthetic or anonymised inputs only,' which is an input-safety rule rather than usage guidance. An agent must guess when this cost-benefit comparison is the right tool.

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

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

Beyond the annotations (readOnly, idempotent, closed-world), the description discloses genuinely useful behavior: inputs are processed transiently and never stored or logged, execution is deterministic server-side for registered kernels, browser mode returns a delegation URL instead of a result, and the call exports an AP2 artifact carrying execution_hash. That is real added context on data handling and output side effects. It stops short of describing what the computed result actually contains.

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

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

The text is a dense metadata block that front-loads provenance plumbing (compute binding, retention policy, artifact hash) rather than the tool's purpose, and it ends with a long dead-weight FV-status URL plus a 64-character receipt hash that no selection decision depends on. Space spent on chain-provenance mechanics crowds out what the tool computes.

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

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

For a four-parameter tool whose core policy_parameters object is left as an untyped free-form bag and explicitly deferred to an external manifest, the description makes no attempt to say what decision inputs the analysis expects or what the AP2 artifact reports. An output schema exists so return values need no explanation, but the agent still cannot tell what to pass to get a meaningful prediction-market analysis.

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

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

Schema description coverage is 100%, so the schema already documents compute, parent_hashes, parent_tool_ids, and policy_parameters. The description restates the compute-mode semantics (auto/server/browser, gpu:true delegation) without adding format or ordering detail beyond the schema, so the baseline 3 applies.

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

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

The only statement of what the tool does is the internal code 'compute node (event_market_pnl)', which restates the title and points at an opaque artifact identifier rather than describing what analyzing a prediction market yields. Nothing distinguishes it in plain language from siblings such as find_prediction_arbitrage, which the description merely names as a downstream consumer.

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 call this versus find_prediction_arbitrage, assess_defi_lending, or any other market-related sibling. The only directives are input-handling constraints ('Use synthetic or anonymised inputs only') and compute-mode routing, neither of which tells an agent when this tool is the right choice.

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

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

Annotations already declare readOnly, idempotent, non-destructive, and closed-world, so the safety profile is covered. The description adds genuinely useful behavior beyond that: determinism, transient processing with no storage/logging/retention, the AP2 artifact + execution_hash export, and the note that the FV-status receipt verifies offline as a snapshot. That is real value over the structured fields.

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

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

The text opens by redundantly restating the title as a prefix, then crams together compute-mode boilerplate, data-retention language, chaining detail, a URL, and a long FV-status hash. The trailing snapshot/hash block is bloated relative to its decision value, and no clear ordering separates purpose from mechanics. Content is present but poorly trimmed and not cleanly 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?

An output schema exists, so return values need not be re-explained, and annotations cover the safety profile. The description covers compute modes, input hygiene, artifact emission, and the downstream consumer, but it never says what the integrity decision actually consumes (policy_parameters are punted to a manifest) or what 'anchoring' verifies, leaving an agent to infer the core input contract.

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

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

Schema description coverage is 100%, so the schema already documents compute, parent_hashes, parent_tool_ids, and policy_parameters in detail. The description largely restates the compute-mode semantics without adding field-level meaning, and it defers policy_parameters field names to a manifest. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description names a specific resource and effect: it is a deterministic OpenChainGraph compute node that anchors document integrity and exports an AP2 artifact carrying an execution_hash for chain provenance. It even names the downstream consumer (art-122-timestamp-attestation-verifier), which helps place it. It does not, however, differentiate itself from the closely-named sibling anchor_stamp, leaving part of the routing decision 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 explains the compute-mode machinery (server vs browser delegation) and an important input constraint ('Use synthetic or anonymised inputs only'), which implicitly scopes usage. But it never states when to choose this tool over anchor_stamp or verify_timestamp_attestation, and no exclusions are given. Usage is implied rather than prescribed.

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?

Annotations already declare readOnlyHint=true, idempotentHint=true, openWorldHint=false, and destructiveHint=false, so safety is covered. The description adds genuinely useful behavior beyond that: deterministic execution, transient processing ('not stored, logged, or retained'), an exported AP2 artifact with execution_hash for chain provenance, and explicit upstream/downstream chaining. Only the compute-mode mechanics are duplicates of the schema.

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

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

The purpose is front-loaded, but the text is a dense run-on with filler ('Deterministic OpenChainGraph compute node' restating the node type) and a long FV-status hash block that crowds out substance. It is neither wildly overlong nor taut, sitting at adequate but loosely structured.

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?

Because an output schema exists, return values need no explanation. The description covers compute modes, data-handling/privacy, provenance chaining, and upstream/downstream artifacts, which is close to complete for a compute node. The one gap is that the semantics of policy_parameters are deferred entirely to an external manifest.

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

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

Schema description coverage is 100%, so the schema already documents compute, parent_hashes, parent_tool_ids, and policy_parameters. The description's compute-mode prose mirrors the schema's own compute definition and leaves policy_parameters fields to the manifest, adding no real meaning beyond the structured data. Baseline 3 applies.

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

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

The tool is identified as a 'Climate Scenario Applicator (NGFS / Fit-for-55)' OpenChainGraph compute node, which names the resource and domain. However, the verb 'apply' is generic and the body says nothing about what the node actually computes (scenario projections, stress outputs), so the purpose is largely carried by the title rather than elaborated. Upstream/downstream artifact references give some differentiation from siblings, but the core function stays 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 select this tool versus alternatives. The only usage constraint offered is 'Use synthetic or anonymised inputs only', and the compute-mode discussion is parameter-level rather than tool-selection guidance. An agent gets no routing signal relative to the many neighbouring compute nodes.

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

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

Annotations already declare readOnly, idempotent, non-destructive, and closed-world, so the safety bar is lower. The description nonetheless adds real context beyond annotations: inputs are processed transiently and not stored/logged/retained, and only synthetic/anonymised inputs should be used — a meaningful handling constraint for the caller. The chain-provenance and compute-delegation behavior is also disclosed.

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

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

The purpose is front-loaded, but the block is dense and mixes identity, compute binding, privacy, chain wiring, a URL, and an FV-status receipt hash. The trailing FV-status hash and snapshot disclaimer are largely noise for tool selection, diluting the actionable sentences.

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

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

With an output schema present, the description need not explain return values, and it appropriately covers compute delegation, privacy handling, and chain wiring via upstream/downstream artifacts. It is nearly complete for a compute node; the only gap is not clarifying the substantive decision content being assembled.

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

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

Schema description coverage is 100%, so the schema already documents compute, parent_hashes, parent_tool_ids, and policy_parameters. The description reinforces the compute-mode semantics and mentions execution_hash/chain provenance but does not add syntax or format detail beyond the schema. Baseline 3 is appropriate.

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

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

The description identifies the tool as an OpenChainGraph compute node and an AI addendum assembler, and names its upstream/downstream artifacts, so the agent can place it in a chain. However, it never states what an 'AI addendum' actually is or what substantive output the tool produces beyond 'an AP2 artifact with execution_hash'. Among many sibling assemble_* tools, the actual assembled content is left implicit.

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

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

It does explain the compute:'auto'/'server'/'browser' selection logic and notes that gpu:true nodes always delegate, which is genuine usage guidance for one parameter. But it offers no explicit 'use this when...' condition versus alternative assembler/compliance tools, and no exclusion criteria beyond the compute-mode mechanics.

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

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

Annotations already declare readOnly/idempotent/non-destructive, and the description goes beyond them by disclosing transient processing with no storage or logging, the browser-delegation behavior for gpu:true nodes, and the execution_hash provenance of the export. The retention/privacy disclosure is the genuinely additive part; the compute-mode text largely duplicates the schema.

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

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

Purpose and lineage are front-loaded, which is good, but the block is padded with a bare HTML URL and a long FV-status receipt sentence whose hash string adds little for an agent deciding how to call the tool. Signal-to-noise is acceptable but not tight.

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 chained compute node with an output schema and full annotation coverage, the description supplies the upstream/downstream lineage, compute-mode behavior, and privacy handling that an agent needs to call it correctly. Return-format detail is rightly left to the output schema; only the when-to-use framing is thin.

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, including the compute enum. The description repeats the compute-mode text almost verbatim from the schema and adds no new meaning for parent_hashes, parent_tool_ids, or policy_parameters, so baseline 3 applies.

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

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

The title line names a specific verb+resource ('AIUC-1 Evidence Pack Assembler') and the body states it 'Exports an AP2 artifact with execution_hash for chain provenance', so the function is unambiguous. It does not name the obvious siblings it could be confused with (assemble_ocg_evidence_bundle, build_evidence_pack, build_226j_response_evidence_pack), instead referring to them only by artifact IDs, so sibling differentiation is weak.

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

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

It gives real invocation constraints ('Use synthetic or anonymised inputs only', compute mode semantics) but never states when to choose this tool over the many sibling evidence-pack builders, nor any prerequisites. Usage is implied by the chain position (consumes art-303 / cry-05, feeds art-305) rather than stated as a selection rule.

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

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

Annotations already declare readOnly, idempotent, non-destructive, closed-world, so safety is covered. The description adds substantive traits beyond that: deterministic computation, transient processing with no storage/logging/retention, a 'use synthetic or anonymised inputs only' warning, kernel/compute-mode delegation semantics, and an execution_hash chained into the export. That is meaningful added context, though some is boilerplate repeated across the node family.

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

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

The compute/privacy/chain sentences earn their place, but the definition is dense and front-loaded with a redundant restatement ('OpenChainGraph compute node' twice) and a long FV-status URL/hash that adds noise for an agent choosing a tool. Information density is high but structure is not cleanly prioritized.

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

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

An output schema exists, so return values need not be explained, and safety is covered by annotations. However, for a compute node whose policy_parameters content is delegate to a manifest, the description gives no domain-level explanation of what license terms are assembled or what the decision function requires, leaving a gap an agent would want filled.

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

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

Schema description coverage is 100%, so the schema already documents compute, parent_hashes, parent_tool_ids, and policy_parameters. The description restates the compute-mode behavior but adds no format or ordering detail beyond the schema, and defers policy_parameters fields to 'the manifest' rather than clarifying them. Baseline 3 when the schema does the heavy lifting.

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

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

The opening 'License Terms Assembler: OpenChainGraph compute node (compliance_mandate). Deterministic OpenChainGraph compute node' largely restates the name/title and self-repeats rather than stating what assembling license terms actually does. It signals the resource and that an AP2 artifact is exported, but never specifies the decision function or output, and gives no differentiation from close siblings like check_license_compatibility, certify_license_election, or select_embedded_license.

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

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

There is no explicit when-to-use or when-not-to-use guidance, and no alternative tool is named for comparison. The chain context ('Consumes upstream from art-204... Output feeds art-206') is positional/provenance information, not advice on when an agent should select this tool versus 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?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so safety is covered. The description adds genuinely useful non-obvious traits: inputs are processed transiently and never stored/logged/retained, execution is deterministic, the output is an AP2 artifact carrying an execution_hash, and the FV-status receipt verifies offline. The 'Exports an AP2 artifact' phrasing is not a true write-back to a resource, so it does not contradict readOnlyHint.

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

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

It is front-loaded with the tool name and role, but the bulk is infrastructure boilerplate (compute binding, Workers, delegation URLs) that crowds out the domain purpose. The FV-status sentence is long and somewhat tangential. It is not padded for its own sake, but the signal-to-noise ratio is poor.

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

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

An output schema exists, so return values need not be described, and the operational envelope (transience, determinism, provenance) is covered. What is missing is domain completeness: nothing tells the agent what a mutual NDA composition should contain or how policy_parameters map to NDA terms, which is the main thing an agent needs to call this correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. The compute-mode text in the description largely duplicates the schema's own 'compute' description, and policy_parameters is deferred to 'the tool's manifest' in the schema rather than explained here. The description adds no 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 opening line names the resource (Mutual NDA) and the tool's role (Composer / compute node for compliance_mandate), so an agent can guess it composes a mutual NDA. However, the description never explains what composing an NDA actually produces or does, and it offers no differentiation from siblings like assemble_ai_addendum, assemble_license_terms, or compose_globe_gir. Most of the text is about compute plumbing rather than the tool's purpose.

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

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

The compute-mode paragraphs describe how the tool executes, not when to choose it over alternatives. The only guidance is 'Use synthetic or anonymised inputs only' and the downstream hint 'Output feeds: art-277-agreement-acceptance-binder.' There is no when-to-use, when-not-to-use, or sibling 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?

Annotations already cover readOnly/idempotent/non-destructive, but the description adds material context: transient server-side processing with no storage, logging or retention, GPU-node delegation behavior, and export of an AP2 artifact with execution_hash for chain provenance. This goes meaningfully beyond the structured 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 opening repeats itself ('OpenChainGraph compute node (attestation_mandate). Deterministic OpenChainGraph compute node.'), and the FV-status URL/hash occupies a full trailing sentence. The operational core is front-loaded, but a sentence of pure redundancy and a long opaque hash hurt density.

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

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

With an output schema present the return shape need not be described, and the description covers compute modes, privacy posture, chaining via parent_hashes, and the provenance artifact. For a deterministic compute node it is largely complete, missing only explicit guidance on when to choose it over sibling evidence-pack tools.

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 compute, parent_hashes, parent_tool_ids and policy_parameters all documented in the schema itself. The description restates the auto/browser delegation semantics already present in the compute enum description, adding no meaning beyond the schema.

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

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

The description identifies the tool as an 'Evidence Bundle Tier Labeler' and an 'OpenChainGraph compute node (attestation_mandate)' with AP2 artifact export, but never states in plain terms what it computes or labels. Against siblings like build_evidence_pack or assemble_aiuc1_evidence_pack, the distinctive 'tier labeling' function is left implicit and an agent must infer it from the name.

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

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

It gives real operational guidance on compute mode selection (auto/server/browser) and a hard constraint ('Use synthetic or anonymised inputs only'). However, it never says when to pick this tool over the many evidence-pack siblings, so routing guidance is absent.

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

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

Annotations already declare readOnly/idempotent/non-destructive, but the description adds real behavioral context beyond them: inputs are processed transiently and not stored, logged, or retained; compute:'auto' is server-side for gpu:false kernels while 'browser' forces a delegation URL; exports carry an execution_hash for provenance; and the FV-status receipt verifies offline. That is meaningful disclosure an agent could not derive from the annotations alone.

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

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

The purpose is buried behind generic OpenChainGraph compute-node boilerplate, and the FV-status sentence carries a 64-character hash and a full URL that consume significant space without helping tool selection. The description is long relative to the decision-relevant information it conveys, and it is not front-loaded on what the assessment does.

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 explain that the return is an AP2 artifact with execution_hash and that it consumes upstream artifacts, which is adequate for the invocation mechanics. But it leaves the core question — what a publish-readiness assessment determines — unanswered, so an agent cannot judge whether the output answers its question.

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

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

Schema description coverage is 100%, so the schema already documents compute, parent_hashes, parent_tool_ids, and policy_parameters thoroughly. The description restates the compute modes and mentions chaining but adds no syntax or format detail beyond the schema. 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 title and first clause identify it as a publish-readiness diagnostic for an agent directory, and the description notes it exports an AP2 artifact and consumes art-133-agent-payment-rail-trust-crosswalk. However, it never states what 'readiness' actually checks or what criteria are evaluated, and the bulk of the text is infrastructure boilerplate rather than purpose. It is distinguishable by name from siblings like run_agentic_readiness_diagnostic only by its narrow subject, not by any description of behavior.

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 some actionable guidance: 'Use synthetic or anonymised inputs only' and the compute-mode selection rules. But there is no when-to-use versus alternatives — nothing routes the agent between this and the many sibling readiness/fit diagnostics (run_agentic_readiness_diagnostic, score_mcp_readiness, run_mcp_deployability_diagnostic). Usage context is implied rather than stated.

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

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

Annotations already declare readOnly, idempotent, non-destructive, closed-world, but the description adds genuinely useful behavior: inputs are processed transiently and not stored/logged/retained, compute modes are explained (server vs browser delegation, gpu:true always delegating), and an AP2 artifact with execution_hash is exported for provenance. This is real context beyond the structured annotations, though it omits anything about error/failure behavior.

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

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

The description is heavily over-stuffed with content that does not aid tool selection: precise statutory deadline dates, a URL, and a long FV-status receipt hash intended for offline verification. The genuinely important information (transient processing, compute-mode behavior) is buried among this regulatory boilerplate. It is not front-loaded around what the tool does.

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

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

With no output schema, the description must convey return behavior, and it partially does: it mentions the exported AP2 artifact with execution_hash and the browser delegation URL. However, it never explains what the conformity decision output actually contains or how results should be interpreted, leaving a real gap for a read/compute tool of this complexity.

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 (compute enum behavior, parent_hashes/parent_tool_ids pairing, policy_parameters container). The description largely restates the compute-mode semantics already in the schema and defers field names to 'the tool's manifest.' Baseline 3 applies because the structured schema does the heavy lifting.

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

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

The title and opening line identify the domain (EU AI Act credit-scoring conformity) and the tool type (an OpenChainGraph compute node), but the description never states in a plain verb+resource form what the node actually computes or returns. The regulatory deadline framing is prominent while the actual function stays abstract. It also does not distinguish itself from closely related siblings such as run_ai_act_highrisk_fit, classify_annex3_decisioning_obligations, or build_ai_conformity_pack.

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

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

The only usage instruction is the constraint 'Use synthetic or anonymised inputs only.' There is no when-to-use vs when-not guidance and no comparison to the many sibling conformity/readiness tools. The note about which downstream tools consume the output ('ml-01-isolation-forest, ptg-01-ap2-prompt-template-generator') hints at position in a pipeline but does not help an agent decide whether to select this tool.

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

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

Beyond the annotations (readOnly/idempotent/non-destructive), the description discloses genuinely useful behavior: server-vs-browser compute delegation semantics, transient non-stored/non-logged processing, the synthetic-input-only constraint, and the AP2 export with execution_hash. That is real context the annotations do not carry.

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

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

The compute/transient/export sentences earn their place, but the FV-status hash sentence and repeated 'OpenChainGraph compute node' phrasing are boilerplate bloat. Front-loaded with infrastructure detail rather than the tool's actual 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?

An output schema exists, so return values needn't be explained, and chain provenance is covered. But the core decision logic and the opaque policy_parameters field names remain unexplained, leaving a compliance agent without the substance needed to call it confidently.

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

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

Schema description coverage is 100%, so the schema already documents compute, parent_hashes, and parent_tool_ids. The description restates compute mode behavior and offers only 'See the tool's manifest for field names' for policy_parameters, adding little beyond the schema — baseline 3.

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

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

The name/title conveys the verb+resource (assess circumvention diligence), and the description situates the tool in an artifact chain between art-94-eccn-dual-use-classifier and art-96/cry-04. However, it never states what the assessment actually evaluates or decides — the 'compliance_mandate' label and chain links do not tell an agent what this node computes.

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

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

It names upstream artifacts consumed and downstream consumers, which hints at pipeline position, but there is no explicit when-to-use, when-not-to-use, or alternative-tool guidance. Nothing directs the agent to prefer this over a generic dual-use classifier or sanctions screener.

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

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

Annotations already declare readOnly/idempotent/non-destructive/closed-world, so the description's added value is genuine: it discloses deterministic execution, server-vs-browser compute routing, that inputs are processed transiently and not stored or logged, and that an AP2 artifact with execution_hash is exported for provenance. That is substantive behavioral context beyond the annotations. Slight deduction because the compute-routing content largely duplicates the schema.

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

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

The opening sentence merely re-states the title, then large blocks of boilerplate about OpenChainGraph compute nodes are front-loaded before anything tool-specific. The final FV-status sentence embeds a 64-character hash URL that is noise for an agent deciding 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?

An output schema exists, so return-value detail is not required. But for a compliance-readiness assessor with a nested policy_parameters object whose fields are deferred to an off-description 'manifest', the description never states what dimensions of Article 14 readiness are tested. The agent is left unable to predict the decision function's inputs or outcomes.

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's only parameter-relevant content is the compute:

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 state a specific verb+resource (assess CRA Art. 14 vulnerability reporting readiness), and the description's opening sentence restates that. However, the body never explains what the assessment actually evaluates; it pivots immediately to compute-node plumbing. An agent can identify the topic but not the substance of the check, and the distinction from the related sibling check_cra_annex1_completeness is only implied by an upstream-consumption note.

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

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

The only directive is 'Use synthetic or anonymised inputs only' and a note that it consumes upstream artifacts from art-139-cra-annex1-completeness-checker. There is no when-to-use guidance, no when-not-to-use, and no explicit routing against the many readiness-assessment 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?

Beyond the annotations (readOnly/idempotent/non-destructive), the description adds real behavior: deterministic execution, server-side vs browser delegation rules, transient non-retention of inputs, and export of an AP2 artifact with execution_hash for provenance. These are substantive operational traits, though it omits what the artifact/response body actually contains.

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 title is front-loaded, but the rest is heavy infrastructure boilerplate (Compute Binding modes, FV-status hash URL, offline receipt verification) that does not help an agent select or invoke the tool. A large share of the text does not earn its place relative to the tool's actual purpose.

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

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

An output schema and annotations are present, so return format and safety are partly covered. But for a tool whose primary input is a free-form nested policy_parameters object, the description gives no hint of what it expects or what the assessment evaluates, leaving a real gap for correct invocation.

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

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

Schema description coverage is 100%, so the baseline is 3 and the description largely repeats the compute-mode semantics already documented in the schema. policy_parameters, the substantive input for the decision function, is left to 'see the tool's manifest' in the schema with no added field-level meaning in the 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 title and the phrase 'analytics_mandate' imply a DeFi lending health/liquidation assessment, giving a resource domain. However, the description never states what the decision function actually computes (collateral ratios, liquidation thresholds, health factors) or what the result contains, so the purpose remains generic. It reads as a provenance wrapper around a named capability rather than a specific verb+resource description.

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

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

There is no guidance on when to use this tool versus near-neighbours such as assess_restaking_risk, compute_ltv_ratios, or run_liquidity_stress_test. The only routing-like text concerns compute mode (auto/server/browser), which is execution plumbing, not task-selection guidance. An agent cannot infer from this text which scenario selects 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 cover the safety profile (readOnly, idempotent, non-destructive, not open-world), and the description adds substantial behavior beyond that: transient processing with no storage/logging/retention, browser-delegation semantics, and an AP2 artifact export carrying an execution_hash for provenance. This is genuinely useful context a caller cannot get from the annotations alone.

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

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

The opening is dominated by repeated infrastructure phrasing ('OpenChainGraph compute node... Deterministic OpenChainGraph compute node'), and the FV-status URL plus a 64-character hash are noise for tool selection. The one useful behavioral line (transient, no retention) is buried mid-paragraph.

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

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

With an output schema and full annotation coverage, the description need not explain return values, and it does cover compute routing and the artifact export. But the core question an agent needs answered, what the readiness assessment produces and what belongs in policy_parameters, is left to an external manifest, so it is only 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%, so the schema already documents compute, parent_hashes, parent_tool_ids, and policy_parameters. The description only echoes the compute enum semantics ('auto'/'browser', gpu:true delegation) and adds nothing for chaining or policy_parameters fields, which it defers to 'the tool's manifest'. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description restates the name and title ('Examination Readiness Pack: OpenChainGraph compute node (compliance_control)') and then spends its length on infrastructure boilerplate. It never states what an examination readiness assessment actually evaluates or what compliance control it checks. An agent learns it is a 'compute node' but not what it computes, and it is not differentiated from the many other assess_* / run_*_readiness siblings.

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

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

It gives a real input constraint ('Use synthetic or anonymised inputs only') and explains the compute-mode selection (auto vs browser vs gpu:true delegation). However, it offers no guidance on when to choose this tool over sibling readiness tools, and no preconditions or exclusions relative to alternatives.

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

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

Beyond the annotations (readOnly/idempotent/non-destructive), the description discloses meaningful behavioral traits: deterministic execution, server- vs browser-side compute modes, transient input processing with no storage or logging, and emission of an AP2 artifact carrying execution_hash for provenance. This is substantive context an agent cannot get from annotations alone; minor gap is lack of stated auth/permission needs.

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

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

The purpose is front-loaded, but the body is dense boilerplate that repeats the compute-mode logic already in the schema and mixes an FV-status URL and an open-page URL into the definition. Some sentences (the FV-status snapshot paragraph) are marginally relevant and dilute the signal.

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

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

An output schema exists, so return values need not be explained, and the description supplies useful completion context – parent hashing for chain provenance, downstream consumer, and offline receipt verification. It is close to complete for correct invocation, lacking only explicit prerequisites/permissions.

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

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

Schema description coverage is 100%, so the schema already documents compute, parent_hashes, parent_tool_ids, and policy_parameters. The description largely restates the compute-mode behavior already present in the schema and adds no new meaning about the chaining or policy_parameters semantics, so baseline 3 applies.

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

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

The description names the resource (ISO 42001 AIMS clause conformance) and identifies the node as a compliance_mandate compute node, but the operative verb is vague – it never plainly says it assesses/evaluates clauses against ISO 42001 controls. It does not distinguish itself from close siblings such as assess_ai_act_conformity, score_clause_coverage, or assess_naic_ais_program_readiness.

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

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

There is no when-to-use guidance or comparison to alternatives. The only constraint offered is 'Use synthetic or anonymised inputs only', and the 'Output feeds: art-172-...' line hints at a downstream consumer but does not tell the agent when this tool is the right choice over other conformance assessors.

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

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

Annotations already cover read/edit safety (readOnly, idempotent, non-destructive, closed-world). The description goes further by disclosing transient processing with no storage/logging/retention, the compute-mode routing (server vs browser delegation), and AP2 artifact/chaining behavior — meaningful operational context beyond the structured fields.

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

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

Content is front-loaded with the purpose phrase, but the opening redundantly repeats 'OpenChainGraph compute node' and dilutes attention with provenance, FV-status hash and URL metadata that an invocation-focused reader may not need. Verbose without being padded to uselessness.

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

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

With an output schema present, return values need not be restated, and the description covers data handling, compute routing, chaining, and upstream/downstream artifact linkage. What remains missing — the actual decision logic and field names for policy_parameters — is deferred to the manifest, which is a reasonable handoff.

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

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

Schema description coverage is 100%, so the schema already documents compute, parent_hashes, parent_tool_ids, and policy_parameters. The description restates the compute modes but adds no new parameter semantics, so the baseline 3 applies.

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

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

The title/name establish a verb+resource (assess MAR-crypto surveillance readiness) and the description adds context that it is a compliance_mandate compute node consuming art-98 and feeding cry-05. However, the description never says what the assessment actually evaluates or returns, so an agent learns the plumbing but not the substance of the tool's purpose.

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

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

There is no explicit when-to-use or when-not-to-use guidance versus the many sibling 'assess_*' tools. The only operative constraint is 'Use synthetic or anonymised inputs only', which is an input requirement, not usage 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?

Annotations already declare readOnly/idempotent/non-destructive, but the description adds real behavioral context: deterministic server-side compute with a registered kernel, browser delegation when compute:'browser' or gpu:true, transient processing with no storage/logging/retention, and an exported AP2 artifact carrying execution_hash for provenance. It also names the upstream artifacts consumed and downstream consumers. That is well beyond the annotation surface.

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

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

The prose is boilerplate-heavy and redundant ('OpenChainGraph compute node' repeated twice back-to-back), and it front-loads plumbing (compute binding, retention, FV-status receipt) ahead of any statement of what the assessment does. Sentences about the offline FV-status snapshot and the marketing URL do little to help an agent invoke the tool.

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

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

An output schema exists, so return values need not be explained, and provenance/upstream/downstream chaining is covered. However, for a domain-heavy compliance assessment the description gives no indication of what 'readiness' means here or what policy_parameters should contain beyond 'see the tool's manifest,' leaving the core invocation under-specified.

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

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

Schema description coverage is 100%, so the schema already documents compute, parent_hashes, parent_tool_ids, and policy_parameters in detail. The description largely restates the compute-mode semantics rather than adding syntax or examples, 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 title and first line identify this as a MiCA CASP authorization-readiness assessor, and the 'compliance_mandate' label hints at scope. But the description never states what the assessment actually evaluates (which CASP authorization criteria are scored, what inputs drive the verdict), so the purpose is only implied by the name. It also fails to distinguish itself from the close sibling 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?

No when-to-use guidance, no prerequisites, and no routing advice versus run_mica_casp_fit or the other MiCA tools (check_mica_register_presence, scope_mica_token_and_service). The only directive is 'Use synthetic or anonymised inputs only,' which is a constraint rather than 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?

Beyond the readOnly/idempotent/non-destructive annotations, the description discloses real behavior: auto vs browser compute delegation, gpu:true always delegating, transient processing with no storage/logging/retention, and export of an AP2 artifact carrying an execution_hash for provenance. That is meaningful context an annotation-stripped view would lack.

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

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

The opening is appropriately front-loaded, but the second half is one dense run-on paragraph and includes a very long FV-status URL plus a raw hex hash receipt that is noise for tool selection. Some sentences earn their place, others do not.

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

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

An output schema exists so return values need not be explained, and the description covers the infrastructure envelope (compute, chaining, data handling). However, the actual decision function and required inputs are deferred to an external manifest, leaving the agent without enough to call the tool 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 enum and array parameters are already documented. The description echoes compute-mode and parent-hash chaining semantics already present in the schema and defers policy_parameters to 'the tool's manifest,' adding little beyond the baseline.

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

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

The description opens by restating the title ('Model Validation Status Assessor: OpenChainGraph compute node') and then spends almost all its words on infrastructure (compute binding, provenance, FV-status). It never states what the assessment actually judges or how it differs from siblings like compute_eba_im_model_validation_tracker, run_model_test_battery, or compare_model_outcome_analysis.

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

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

There is no explicit when-to-use versus alternatives guidance. The only usage instruction is a data constraint ('Use synthetic or anonymised inputs only') and a note that it consumes art-451-model-outcome-analysis, which implies positioning but does not tell the agent when to pick this tool.

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

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

Annotations already declare readOnly/idempotent/non-destructive/openWorld=false, and the description adds genuinely useful behavioral context beyond them: transient processing with no storage/logging/retention, a mandate to use synthetic or anonymised inputs, deterministic execution, and an AP2 artifact with execution_hash for provenance. This exceeds the annotation baseline, though the compute-mode paragraph largely duplicates the schema.

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

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

Reasonably front-loaded with title and node type, but the body is a dense block of infrastructure boilerplate, including a compute-mode explanation that duplicates the schema and a long FV-status/receipt sentence. Much of it is template text rather than assessment-specific content, yet it remains readable as a single pass.

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

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

With no output schema, the description should describe what the assessment produces; it only says an AP2 artifact with execution_hash is exported, not what the evaluation result contains. The policy_parameters object is explicitly deferred to an external manifest, leaving decision inputs opaque. Data-handling and compute routing are well covered, so it is adequate but incomplete for a compliance assessment tool.

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

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

Schema description coverage is 100%, so all four parameters are already documented in the schema, including the compute enum and the role of parent_hashes/parent_tool_ids. The description's only added parameter value is naming the upstream artifact (art-239-test-bifsg-bias-thresholds) that feeds the chain; otherwise it restates schema content. 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/title convey a specific verb+resource (assess NAIC AI systems program readiness), and the description confirms it is an OpenChainGraph compute node. However, the description never explains what the assessment actually evaluates (criteria, scoring, verdict) and gives no basis to distinguish it from siblings like assess_iso42001_aims_conformance or assess_mica_casp_readiness. The first sentence merely restates the title.

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

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

No guidance on when to use this tool versus the many other readiness/conformance assessments in the sibling list. The only usage-like content is the compute-mode routing, which is invocation mechanics rather than tool selection or prerequisites. An agent cannot tell from the description when this assessment is the right one.

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

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

Beyond the annotations (which cover the safety profile), the description discloses substantial behavior: transient input processing with no storage/logging/retention, deterministic execution, server-vs-browser delegation semantics including the gpu:true rule, and an exported AP2 artifact carrying execution_hash for chain provenance. That is real behavioral context the annotations do not provide.

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

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

The content is front-loaded with node type and regulatory deadline, but the text is dense with parenthetical asides, an external URL, and a long FV-status hash string that reads more like provenance noise than actionable guidance. It is informative but not tightly scoped.

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 an output schema exists, return values need not be explained, and the description covers compute modes, data handling, artifact export, and downstream consumers adequately for a high-complexity compliance node. The remaining gap is that it never states what the readiness assessment actually evaluates, deferring the decision fields to the tool's manifest.

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

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

Schema coverage is 100%, so the baseline is 3. The description restates the compute-mode semantics that the schema already documents and says nothing extra about parent_hashes/parent_tool_ids, and it explicitly defers the policy_parameters field names to an external manifest, so no marginal parameter meaning is added.

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 establishes a specific regulated resource (PSD3/PSR readiness) and characterizes the tool as a deterministic OpenChainGraph compliance compute node with a concrete regulatory deadline. The verb+resource is clear, though the actual assessment the checker performs is largely implied by the title rather than stated, and it does not explicitly distinguish itself from the many other 'assess_*_readiness' siblings.

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

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

Usage context is implied through the compute-mode guidance ('auto' vs 'browser' vs 'server') and the 'Use synthetic or anonymised inputs only' constraint, plus the two downstream tools the output feeds. However, there is no explicit when-to-use/when-not or named alternative among siblings, leaving routing largely to inference.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is largely covered. The description does add real behavioral context beyond that: deterministic execution, transient input processing ('not stored, logged, or retained'), a synthetic-inputs-only constraint, and export of an AP2 artifact with execution_hash for provenance. These are useful, though the determinism point is stated twice.

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 title but then spends most of its length on infrastructure detail (compute binding, Workers, FV-status JSON path) rather than the tool's actual behavior. 'OpenChainGraph compute node' and 'Deterministic OpenChainGraph compute node' are redundant, and the FV-status/URL sentence is verbose. It is not bloated enough to be unusable, but several sentences do not serve tool selection.

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

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

The tool has an output schema and a nested policy_parameters object whose fields are explicitly undisclosed ('See the tool's manifest for field names'). For a decision/analysis tool with a nested input object and zero required parameters, the description should explain what the decision function computes and what policy fields matter; instead it spends its budget on deployment mechanics. The one genuinely useful completeness detail is the AP2/execution_hash export note.

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

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

Schema description coverage is 100%, so the schema already documents compute, parent_hashes, parent_tool_ids, and policy_parameters. The description's compute-mode sentences essentially duplicate the schema's own compute description, adding no syntax or semantics beyond it, and policy_parameters is deferred to 'the tool's manifest.' Baseline 3 applies when the schema does the heavy lifting.

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

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

The title names a specific resource (restaking delegation and slashing risk), but the description itself never states what the tool actually computes or returns for that risk. Instead it opens with infrastructure boilerplate ('OpenChainGraph compute node (analytics_mandate). Deterministic OpenChainGraph compute node.'), which restates the product context rather than the tool's function. An agent learns nothing about the restaking analysis beyond what the name already says.

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

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

There is no when-to-use guidance and no comparison to the many sibling assess_* tools (assess_defi_lending, assess_mar_crypto_surveillance, etc.). The only conditional guidance concerns the compute mode, which is parameter mechanics rather than usage selection. Nothing tells the agent when this tool is the right choice.

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

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

Annotations already declare readOnly/idempotent/non-destructive, so the description's added value is limited. It does add real behavior beyond annotations — compute mode selection, transient non-retention of inputs, AP2 artifact export with execution_hash, and parent-hash chaining — but all of this is generic node plumbing rather than tool-specific behavior (what triggers a quarantine verdict, what it returns).

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

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

The opening labels the tool correctly, but the rest is padded: compute-mode semantics are explained twice (description and schema), and a long FV-status URL/receipt sentence adds provenance trivia rather than tool guidance. Very little of the length is load-bearing for an agent deciding whether to call 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?

This is a compliance assessment with a nested, undefined policy_parameters object and an upstream artifact dependency, yet the description never says what the assessment evaluates, which inputs drive it, or what the verdict means. The output schema spares it from explaining return values, but the core decision semantics are absent.

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, so the baseline is 3. The description restates the compute modes that the schema already covers in detail but adds nothing about policy_parameters field names, deferring to 'the tool's manifest.'

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

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

The name and title identify the domain (DSCSA suspect/illegitimate product quarantine assessment), but the description body never states what the assessment actually computes or decides. It substitutes infrastructure boilerplate ('OpenChainGraph compute node (compliance_mandate)') for a purpose statement, and gives no differentiation from the many other assess_* siblings.

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

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

There is no when-to-use guidance, no conditions, and no alternatives named. The only routing hint is the upstream dependency ('Consumes upstream artifacts from: art-113-saleable-returns-verifier'), which tells the agent about chaining but not when this tool is the right 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?

Annotations already declare readOnly/idempotent/non-destructive/closed-world, but the description adds real disclosure beyond them: inputs are processed transiently and not stored, logged, or retained, only synthetic/anonymised inputs should be used, an AP2 artifact with execution_hash is exported for provenance, and gpu:true nodes always delegate to the browser. These are meaningful operational constraints an agent cannot get from the annotations.

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

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

Purpose-relevant content is front-loaded, but the paragraph is a run-on that mixes infrastructure, privacy, artifact export, a downstream-feed pointer, a URL, and an FV-status receipt hash. The FV-status sentence in particular is boilerplate that consumes length without helping an agent decide or call correctly.

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

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

For a 4-parameter node with an output schema, the description covers compute routing, privacy handling, chaining via parent hashes, and the artifact it emits. The main gap is that policy_parameters' actual field semantics are deferred to an external manifest rather than summarized, but the tool is otherwise callable from this definition.

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 merely paraphrases the compute enum (already fully specified in the schema) and says nothing about how policy_parameters fields are determined beyond deferring to 'the tool's manifest'. Baseline 3 is correct when 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 name and title say 'TRAIGA Exposure Assessor' and the description labels it a 'deterministic OpenChainGraph compute node (compliance_mandate)', so the agent can infer it computes a TRAIGA exposure metric. However, the body spends most of its length on compute substrate mechanics (server vs browser, GPU delegation, AP2 export) rather than stating what the assessment actually evaluates or returns, and it never distinguishes itself from the dozens of other 'assess_*' siblings.

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

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

There is no explicit when-to-use or when-not-to-use statement. The only routing hint is 'Output feeds: art-314-traiga-safe-harbor-pack-builder', which tells the agent where the output goes but not when this tool is the right choice over adjacent compliance assessors. The compute-mode guidance is parameter behavior, not invocation guidance.

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

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

Beyond the annotations (readOnly, idempotent, non-destructive, closed-world), the description discloses genuinely useful behavior: deterministic compute, transient input processing with no storage/logging, server-side vs browser-delegation semantics, and export of an AP2 artifact carrying execution_hash for provenance. It stops short of describing the response payload or any failure modes, but the added behavioral context is substantial.

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 are redundant ('OpenChainGraph compute node ... Deterministic OpenChainGraph compute node'), and the trailing FV-status/hash and URL are bulky boilerplate. The compute-mode and transient-processing sentences do earn their place, but the description is padded and front-loads meta-framing rather than the tool's actual 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?

There is no output schema, so the description carries the burden of explaining what the assessment returns — and it does not. The key input, policy_parameters, is explicitly deferred ('See the tool's manifest for field names'), leaving the agent without the fields needed to invoke the tool meaningfully for a compliance assessment.

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

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

Schema description coverage is 100%, so the parameters are already documented; the description only echoes the compute-mode behavior already present in the schema. It adds no extra meaning for parent_hashes/parent_tool_ids beyond what the schema says, so the baseline 3 applies.

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

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

The description never states in plain terms what the assessment actually determines about ViDA DRR reporting obligations; it opens with infrastructure framing ('OpenChainGraph compute node (compliance_mandate)') that largely restates the title. Sibling tools like assess_vida_recapitulative_migration, run_vida_readiness_diagnostic and validate_vida_einvoice_conformance are not distinguished, so an agent cannot tell from the text what output this produces or how it differs.

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 documents compute-mode selection (auto/server/browser) and the upstream/downstream artifact chain, which is operational context, but it never says when to choose this assessment versus the many other ViDA tools (recapitulative migration, e-invoice conformance, OSS registration). No prerequisites, no exclusions, no alternative 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?

Beyond the annotations (readOnlyHint/idempotentHint true, destructive/openWorld false), the description discloses genuinely useful traits: deterministic execution, server-side vs browser delegation behavior, transient processing with no storage/logging/retention, and export of an AP2 artifact carrying execution_hash for provenance. These are real operational properties the annotations do not cover.

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

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

It opens with a redundant name/title restatement and repeats "Deterministic OpenChainGraph compute node" verbatim, then buries the one domain-relevant fact (upstream artifact) inside infrastructure boilerplate. The wall of compute-binding and FV-status text is not sized to what an agent needs to select the tool.

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

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

For a 4-parameter tool with a nested policy_parameters object and no output schema, the description omits the core information: what the assessment decides and what fields drive it. It covers compute modes, data handling, and artifact export, but an agent still cannot predict the tool's outcome or how to populate policy_parameters.

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

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

Schema description coverage is 100%, so the schema already documents compute, parent_hashes, parent_tool_ids, and policy_parameters. The description only restates compute-mode semantics that already appear in the schema and defers policy_parameters fields to "the tool's manifest," adding no new parameter meaning. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description mostly restates the name and title ("ViDA Recapitulative Statement Migration Assessor: OpenChainGraph compute node") and never explains what a recapitulative-statement migration assessment actually evaluates or returns. It gives no differentiation from close siblings like assess_vida_drr_reporting_obligation, run_vida_readiness_diagnostic, or validate_vida_einvoice_conformance. The only added substance is the upstream artifact reference, which is provenance rather than purpose.

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

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

There is no when-to-use guidance and no routing to alternatives among the many vida/assess siblings. The only constraint given ("Use synthetic or anonymised inputs only") is an input-handling rule, not a selection criterion. An agent cannot tell from this text when this tool is the right choice versus 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.