AINumbers Fintech Intelligence Suite

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

Annotations already declare readOnly/idempotent/non-destructive/closed-world, and the description still adds real value: 'No network egress', a pinned table of exactly 6 GLEIF vLEI schema SAIDs, the finding vocabulary (match/mismatch/unsupported/unknown), and a receipt. The only gap is no indication of error behavior for malformed/unparseable credentials.

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

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

Front-loaded with the core action and the crucial scope disclaimer lands well, but the first half is cluttered with internal references ('tools/553 browser workbench (VS-1)', 'T553', 'vendored SAID-check module') that give an external caller no actionable information. Trimming those would sharpen it without losing meaning.

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

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

No output schema exists, and the description compensates by naming the return payload (per-field findings plus a receipt) and the full limitation set. Complete enough to call correctly; only the failure mode for invalid JSON is unaddressed.

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

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

Schema coverage is 100% and the single parameter is documented, so baseline would be 3. The description nonetheless adds domain meaning: which fields are SAID-checked (d, nested e/a/r, s) and that the s value is compared against a fixed external table, which tells the agent what a usable credential must contain.

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?

Specific verb+resource: 'recomputes the self-addressing identifiers (SAIDs) of a pasted ACDC / vLEI credential JSON', including which blocks (top-level d, nested a/e/r) and which derivation codes (E/I). It also explicitly bounds the scope against adjacent siblings (verify_acdc_delegation_chain, verify_revocation_status) by stating it is NOT chain-of-trust, issuer authority, or revocation.

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 exclusions ('STRUCTURAL check only -- NOT the KERI chain of trust, NOT issuer authority, NOT revocation state') give a clear use/don't-use boundary that helps an agent route elsewhere for those questions. However, no sibling tool is named as the alternative, so the routing is inferred rather than explicit.

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

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

Annotations already cover safety (readOnly, idempotent, non-destructive, closed-world), so the bar is lower, and the description still adds real context: server-side vs browser compute delegation, transient non-logged processing, and that an AP2 artifact with execution_hash is exported for chain provenance. The gap is that it never explains how the verdict is derived or what a disagreement with the TR means operationally.

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?

Dominated by infrastructure boilerplate — compute-node preamble, duplicated 'Deterministic OpenChainGraph compute node' sentence, an FV-status hash URL, and a documentation link — all placed ahead of the actual EMIR explanation. The valuable domain content sits near the end and is hard to reach.

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?

Outputs are enumerated and describe_tool is pointed to for the schema, which covers return values adequately. But for a tool whose three nested inputs are untyped objects, the description should say what a firm_state, tr_response, or policy payload must contain; that omission is a meaningful 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 coverage is 100%, so the baseline is 3. The description does add some meaning by explaining that a firm holds a TR response plus its own submitted state, which hints at the firm_state and tr_response parameters, but it says nothing about the internal shape of the nested policy/firm_state/tr_response objects, which are declared as untyped open objects 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 domain summary explains the EMIR Refit inter-TR reconciliation context and lists concrete outputs (break_count, tr_disputed_count, verdict_disagrees_with_tr_count), so an agent can infer it adjudicates TR-returned breaks against the firm's own state. However the operational verb is never stated plainly and the description never distinguishes it from close siblings like reconcile_emir_pairing, age_emir_reconciliation_breaks, or check_emir_uti_completeness.

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 the privacy caveat 'Use synthetic or anonymised inputs only.' There is no statement of when this tool applies versus reconcile_emir_pairing or the break-ageing sibling, and no prerequisites such as needing a TR ISO 20022 response plus submitted state before calling.

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, non-destructive, and closed-world behavior. The description adds useful behavioral context beyond annotations by stating that inputs are processed transiently and not stored/logged, and that the tool exports an AP2 artifact with execution_hash provenance. However, it does not explain the break-ageing behavior itself, error conditions, or what the resulting artifact 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 description is bloated with repeated platform boilerplate, a URL, an FV-status hash, and provenance details that do not help an agent select or invoke the tool. The actual purpose statement is cut off mid-sentence, so the structure is not front-loaded and the useful content is obscured.

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 complex compute tool with nested policy_parameters and no output schema, yet the description does not complete its explanation of the ageing computation or define the partially listed output fields. It does mention upstream chaining and data-handling constraints, but those are not enough to make the definition complete for correct invocation.

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

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

Schema description coverage is 100%, so the schema already documents compute modes, parent hashes/tool IDs, and policy_parameters. The description mainly repeats the compute-mode text and names the upstream artifact, but adds little semantic detail about how current_break_set, prior_sealed_break_set, or policy should be structured. Baseline 3 is appropriate when the schema carries the 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 title and opening line identify the resource as EMIR reconciliation break ageing, and the partial summary says it 'Diffs a current EMIR reconciliation break set.' However, the purpose sentence is truncated and buried under platform boilerplate, so it is not clear what ageing logic is performed or how it differs from close siblings such as reconcile_emir_pairing or adjudicate_emir_reconciliation.

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

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

The description gives no explicit when-to-use or when-not-to-use guidance, nor does it name alternatives. It mentions consuming upstream artifacts from art-482-emir-recon-adjudicator, which implies a chaining context, but does not explain when an agent should choose this tool over other EMIR reconciliation 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?

Built on annotations that already declare read-only, idempotent, non-destructive, and closed-world behavior, the description adds meaningful runtime context: browser-based, client-side only, zero PII, zero network, and rendered as an interactive AINumbers widget. It does not discuss persistence or rate limits, but it substantially clarifies operational behavior beyond the annotations.

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

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

The core purpose is front-loaded and the description is appropriately short for the tool. There is minor redundancy around client-side and zero PII behavior, but it remains readable and does not bury the primary usage.

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

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

For a one-parameter sandbox tool with strong annotations and full schema coverage, the description covers purpose, input application, runtime environment, and output intent. It does not explain the Policy Mandate return payload in detail, but it explicitly points the caller to describe_tool for 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 coverage is 100%, and the single inputs parameter is already documented as a map of input element IDs to values applied via AIN Bridge prefill. The description repeats the AIN Bridge application but does not add mapping details, examples, or key-level semantics beyond what the schema provides.

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

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

The description gives a specific verb and resource: simulate agent payment policies for tokenized A2A corridors, configure policy controls, run synthetic transactions, and export a Policy Mandate. It is clear what the tool does, but it does not explicitly distinguish itself from similar siblings such as simulate_agent_spend_policy or simulate_spend_policy.

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

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

The description clearly establishes the usage context: simulating payment policies and running synthetic transactions before exporting a Policy Mandate. It does not state when to choose this tool over similar simulation siblings, but the sandbox/widget framing gives useful context with no misleading exclusions.

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

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

Annotations already declare readOnly, idempotent, non-destructive, closed-world, so the safety profile is covered. The description still adds genuinely useful behaviour beyond that: server-side vs browser delegation rules, transient non-retained input processing, and export of an AP2 artifact carrying execution_hash for chain provenance.

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

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

Roughly half the text is reusable template boilerplate (compute binding, privacy notice, FV-status hash URL) that buries the actual purpose. The summary sentence is truncated mid-clause ('in a steel/aluminium value chain (incl. Outputs:'), which is a structural defect, not concision.

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 does list the return fields (cumulative_see_tco2e, data_quality_grade, precursor_breakdown, etc.) and names upstream/downstream artifacts, which helps. But the truncation of the defining sentence and the absence of any domain parameter meaning leave the agent guessing about what inputs the aggregation actually expects.

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% with per-parameter descriptions, so the schema already carries the semantics --- baseline 3. The description restates the compute:"auto" default and artifact-chaining intent but adds nothing about policy_parameters content (final_good, precursors, scrap_input_share), whose nested keys have no descriptions in either place.

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 core purpose is stated ('Rolls up embedded emissions across precursors in a steel/aluminium value chain') but arrives at the very end of the description and is truncated mid-sentence, so the agent must parse boilerplate to find it. No differentiation is offered against close siblings such as calculate_cbam_embedded_emissions, resolve_cbam_default_value, 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?

No guidance on when to choose this aggregator over calculate_cbam_embedded_emissions or run_carbon_compliance_fit, and no prerequisites stated. The only conditional behaviour mentioned is the compute mode, which is execution plumbing 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?

Annotations already declare readOnly/idempotent/non-destructive, and the description adds real behavioral context beyond them: the compute:auto vs compute:browser server-vs-client execution split, that gpu:true nodes always delegate, transient no-retention processing, the synthetic-inputs-only constraint, and that an AP2 artifact with execution_hash is exported. These are meaningful traits, though much of the wording is generic compute-node boilerplate rather than specific to receipt aggregation.

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 repeated boilerplate ('OpenChainGraph compute node' twice), a raw URL, and a 64-hex FV-status path, while the only true purpose statement ('Summary: The regulatory receipt') is buried at the very end. Front-loading is poor and several sentences do not earn their place.

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

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

With no output schema, listing the output fields is genuinely useful, and the upstream/downstream artifact references plus privacy and compute-mode notes round it out. However, it never explains what the aggregation actually does with the consumed artifacts or what 'all_proofs_verified' means for the caller, leaving real gaps for a 4-parameter nested-object 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 coverage is 100%, so the schema already documents compute enum behavior, parent_hashes/parent_tool_ids ordering, and that policy_parameters requires 'artifacts'. The description restates the compute-mode semantics but adds nothing about what artifact objects the policy_parameters array should contain or how chaining behavior works in practice.

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

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

The description labels the tool 'Agent-Action Audit-Trail Aggregator' and 'The regulatory receipt', and the listed outputs (merkle_root, n_receipts, tree_depth, session_receipt_root) hint that it aggregates receipts into a merkle tree, but the actual verb+resource statement never appears explicitly. Nothing distinguishes it from siblings like validate_agent_audit_trail, build_session_receipt, or the many other 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?

There is pipeline context ('Consumes upstream artifacts from: ... Output feeds: ptg-01-...') but no statement of when to call this tool, when not to, or which sibling to prefer for a similar audit-trail task. An agent must infer usage from the artifact IDs alone.

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

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

Annotations only declare readOnly/idempotent/non-destructive; the description adds substantial context beyond them — deterministic execution, transient non-stored inputs, server vs browser compute delegation, and AP2 export with execution_hash for provenance. This is exactly the extra behavioral context the annotations cannot 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?

Core summary is front-loaded and useful, but the definition is padded with provenance boilerplate (FV-status hash URL, artifact-consumption list, 'deterministic OpenChainGraph compute node' repetition) that does not help an agent decide or invoke. Structure is fine; sizing is bloated.

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

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

With no output schema, the description compensates by enumerating the return fields (blocked_count, entity_verdicts, etc.) and pointing to describe_tool. Annotations cover the safety profile, so this is close to complete, missing only explicit sibling differentiation.

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 both compute and policy_parameters are already documented in the schema. The description echoes the compute semantics and notes thresholds/ownership_graph are consumed by the decision function but adds no new syntax or constraints, 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?

States a specific verb and resource ('walks a synthetic ownership graph; computes direct + indirect + aggregate listed stakes') and names the OFAC/EU/BIS 50%-thresholds applied. It does not explicitly distinguish itself from the similarly-named sibling compute_cdd_ownership_25pct, so it stops short of a 5.

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

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

The compute-mode behavior and 'use synthetic or anonymised inputs only' constraint are explained, and upstream/downstream artifacts are named. But there is no explicit when-to-use vs when-not or guidance on choosing this over the 25%-rule sibling, leaving selection 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 cover the read-only/idempotent/non-destructive profile, yet the description adds real behavioral context: inputs are processed transiently and not stored or logged, results are deterministic, an AP2 artifact with execution_hash is exported, and the FV-status receipt is a snapshot verifiable offline. The main weakness is that much of this is stated in dense internal jargon rather than plain 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 description opens with redundant restatements ("OpenChainGraph compute node... Deterministic OpenChainGraph compute node") and includes a long FV-status URL plus a pointer to describe_tool for the output schema. The single most useful sentence, the Summary, is placed near the end 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 no output schema, the description compensates by enumerating the return fields (as_of, attestation_count, composite, dims, insufficient_evidence, etc.), and it covers execution routing, data handling, and provenance. What is missing is any explanation of how insufficient_evidence or excluded_self_issued are determined, which matters for a scoring 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 (including the nested policy_parameters object) are already documented, which sets the baseline at 3. The description does explain compute-mode semantics again and mentions execution_hash chaining, but adds little on parent_hashes/parent_tool_ids pairing or the nested decay/subject fields beyond what the schema states.

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

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

The Summary sentence gives a precise verb and resource: aggregates OCG execution receipts into a deterministic, groth16-provable reputation score across four named dimensions. However, this clarity is buried after several lines of compute-node boilerplate, and no sibling (e.g. aggregate_execution_receipts) is named to disambiguate.

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 concrete guidance on the compute modes ("auto" server-side for gpu:false kernels, "browser" forces a delegation URL, gpu:true always delegates) and a caution to use synthetic/anonymised inputs. But there is no statement of when this tool should be chosen over the many sibling aggregation tools, leaving tool selection to inference from the name.

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

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

Annotations already cover read-only/idempotent/non-destructive, and the description adds genuinely new context: compute-mode delegation behavior, transient no-storage processing, synthetic-input requirement, and an AP2 artifact with execution_hash for provenance. Deductions for the truncated sentence and boilerplate FV-status hash paragraph that don't aid invocation.

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

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

Purpose is front-loaded and the calculation detail earns its place, but the text is bloated with boilerplate (full FV-status URL with hash, 'Deterministic OpenChainGraph compute node' repeated) and is truncated mid-sentence ('...adds the operational risk charge an...').

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

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

For a read-only compute node, the description supplies the enumerated outputs, the downstream consumer, and the safety/privacy profile. It falls short only on the internal structure of policy_parameters, which an agent needs to construct a valid call.

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

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

Schema coverage is 100%, so the schema already documents compute, parent_hashes, parent_tool_ids and policy_parameters; the description largely repeats the compute-mode semantics. It does not explain what the nested policy_parameters.modules / policy_parameters.operational objects should contain, leaving the core inputs undescribed beyond the schema stubs.

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

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

States a specific verb+resource: aggregates the five Solvency II standard-formula risk-module charges into Basic SCR via the Annex IV correlation matrix, then adds operational risk. The downstream feed (art-180-solvency2-scr-ratio-calculator) implicitly distinguishes it from the ratio calculator sibling, though the comparison is not made explicit.

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

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

Usage is only implied: the 'Output feeds' line signals where results go, letting an agent infer this is the upstream module-aggregation step. There is no explicit when-to-use/when-not or named alternative among siblings like calculate_solvency2_scr_ratio.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), yet the description adds real value beyond them: transient no-store/no-log processing, a 'synthetic or anonymised inputs only' requirement, deterministic execution, and that an AP2 artifact with execution_hash is exported for chain provenance. Compute-mode delegation behavior (server vs browser, gpu:true always delegates) 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?

Lead sentences restate the title and repeat "deterministic OpenChainGraph compute node" twice, which is wasted space, while the substantive compute-mode and privacy statements are buried mid-paragraph. The trailing FV-status receipt URL is long and low-value relative to the missing purpose statement.

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 cover the returned artifact and execution_hash, which is helpful. However, for a tool whose only substantive input is an underspecified policy_parameters object, an agent still cannot construct a valid call without fetching the external manifest — a notable gap given the nested-object 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 compute, parent_hashes, and parent_tool_ids are already well documented; the description merely echoes the compute-mode semantics that the schema states verbatim. The critical policy_parameters object is left to "See the tool's manifest for field names" in both schema and description, so the description does not compensate for the one genuinely opaque parameter.

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 repeats the title ("Summa MST Liability Aggregator") and labels the tool a "deterministic OpenChainGraph compute node," but never states in domain terms what is being aggregated or computed — no mention of what a liability set is, what the decision function does, or what the output represents beyond an AP2 artifact. The only differentiator from the many sibling aggregate_* tools is a downstream consumer URL (art-620-summa-mst-inclusion-checker).

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 named alternative among the numerous sibling aggregate_* / compute_* tools. Pipeline position is only implied through "Output feeds: art-620-summa-mst-inclusion-checker" and the parent_hashes chaining hint, leaving the agent to infer invocation conditions.

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

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

Annotations already declare readOnlyHint, idempotentHint and destructiveHint=false, so safety is covered; the description adds compute-mode behavior (auto/server/browser, gpu:true always delegates), that inputs are processed transiently and not retained, and that an AP2 artifact with execution_hash is exported. Those are real behavioral facts beyond the annotations. Some of this is repeated boilerplate rather than tool-specific detail.

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

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

The definition is long and poorly front-loaded: the domain purpose is buried after OpenChainGraph compute-node boilerplate, privacy language, an artifact URL and an FV-status hash. It also repeats itself ('Deterministic OpenChainGraph compute node' appears twice), so several sentences do not earn their place.

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

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

Outputs are enumerated, upstream/downstream artifacts are named, and compute/retention behavior is described, which suits a complex node with no output schema. But the nested policy_parameters object is opaque in both schema and description, and there is no explanation of denominator inputs like total_assets or covered_assets that the GAR calculation depends on.

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

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

Schema description coverage is 100%, so the baseline is 3. The description restates the compute-mode semantics already documented in the schema and does not explain the nested policy_parameters keys (activities, entity_type, total_assets, covered_assets, gar_numerator_items) or parent_hashes/parent_tool_ids beyond what the schema already says.

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 Summary sentence states a specific verb and resource: it 'rolls activity-level Taxonomy alignment (from ART-73) into entity KPIs' including revenue/CapEx/OpEx aligned proportions and the Green Asset Ratio under the Disclosures Delegated Act denominator rules. That is far more specific than the title, and naming the upstream ART-73 scorer distinguishes it from sibling score_taxonomy_alignment. However, the actual purpose appears only near the end, after several sentences of platform boilerplate.

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

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

Usage is only implied through lineage: it consumes art-73-taxonomy-alignment-scorer and feeds cry-05-agent-action-audit-trail-aggregator, which tells the agent where it sits in a pipeline. There is no explicit when-to-use/when-not guidance and no named alternative such as score_taxonomy_alignment. The only direct constraint is 'Use synthetic or anonymised inputs only.'

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 genuine value beyond them: inputs are processed transiently and not stored or logged, synthetic/anonymised inputs are required, server-vs-browser delegation rules govern execution, and an AP2 artifact with execution_hash is exported for provenance. These are exactly the operational traits structured fields cannot express; only the rambling FV-status hash sentence dilutes it.

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

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

It is bloated with low-value content: a full URL, a 64-character FV-status hash embedded in a path, legalistic provenance boilerplate, and a closing instruction to 'call describe_tool' for the output schema. The actual purpose statement is buried behind compute-node plumbing, so the text is not front-loaded on what the agent needs.

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

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

There is no output schema, but the description enumerates the returned fields (score, adj_score, tier, prob, median_salary_usd, alts), which compensates somewhat. However, for a scoring tool it never explains what the score/tier mean, how policy_parameters map to the result, or what 'alts' contains, leaving the agent able to call it but not interpret it.

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

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

Schema coverage is 100%, so the schema documents compute, parent_hashes, parent_tool_ids and the policy_parameters block, giving a baseline of 3. The description does add one useful fact not in the schema (the nested required keys rc/rm/nra/nri/nrm/sector_exp/ed_level/years_role, since the top-level required array is empty), but it never decodes those cryptic acronyms, so semantic meaning is still absent.

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 only by restating its own name ('Port of ApexLogics Apex #104 (AL-111) AI Displacement Risk Screener'), which is close to tautological. The output-field list (score, tier, prob, routine_frac, sector_exp, automation_pct) lets an agent infer that it scores occupation-level AI displacement risk, but the description never states that in a verb+resource sentence.

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

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

There is guidance on the compute parameter ('auto' vs 'browser' delegation) but nothing on when an agent should pick this screener over siblings such as classify_agentic_ai_risk, classify_ai_system_governance, or run_ai_act_highrisk_fit. With a large sibling set of AI-risk tools, the absence of routing guidance is a real gap.

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 genuine behavioral traits: transient server-side processing with no storage or logging, the auto/server/browser compute split with gpu:true always delegating, and export of an AP2 artifact carrying execution_hash for provenance. Missing only things like latency, failure modes, or whether the FV-status receipt affects 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 opening repeats itself ('OpenChainGraph compute node (analytics_mandate). Deterministic OpenChainGraph compute node') and the single most useful sentence, the Summary, is buried near the end. The provenance-hash URL and offline-verification note consume significant space 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?

For a four-parameter nested-policy tool with no output schema, the description covers the important ground: what it computes, required policy keys, upstream chaining inputs, compute-mode behavior, and an explicit enumeration of output fields. Data-handling and provenance expectations are also set.

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

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

Schema description coverage is 100%, so the compute enum, parent_hashes/parent_tool_ids ordering, and policy_parameters keys are already documented. The description largely restates the compute modes and adds only the list of required policy_parameters, which sits at the baseline for a fully-documented 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 Summary sentence states a specific verb and resource — 'Allocates overnight in-house-bank (IHB) interest across notional pool or ZBA sweep members' — and the upstream-artifact list (multilateral netting, EBAM/ACMT validation) helps place it among siblings. However, the tool's actual purpose appears late, after several sentences of compute-node boilerplate, and no sibling is named as an alternative.

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 rather than stated: it consumes artifacts from art-259/compute_multilateral_netting and art-262/validate_ebam_acmt_flow, and requires synthetic or anonymised inputs. There is no explicit when-to-use vs when-to-use-another-tool guidance, and no named alternative for IHB allocation work.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), and the description adds genuinely new context: gpu:true nodes always delegate to the browser, inputs are processed transiently and not retained, synthetic/anonymised inputs are required, and the call exports an AP2 artifact carrying execution_hash for chain provenance. That extra disclosure is substantive rather than a restatement of the annotations.

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

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

The purpose is buried behind repeated infrastructure boilerplate ('OpenChainGraph compute node ... Deterministic OpenChainGraph compute node'), a verbatim restatement of the compute enum already in the schema, and a 64-character FV-status hash URL. The dangling list of 15 output field names at the end is unstructured, and the front-loaded content is process plumbing rather than 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 does enumerate output fields and explain compute modes, privacy and provenance, which covers a lot. But it never explains what the returned flags actually mean (impairment_flag, incremental_cost_test_passed, renewal_treatment) or the semantics of the nested policy_parameters, leaving gaps for a compliance calculation 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 parameter contract is already documented and the 3 baseline applies. The description adds a little meaning for policy_parameters through the expedient rule keyed on contract_term_months, but the other keys (renewal_cost, incremental_cost, impairment_indicators, renewal_commensurate, amortization_period_override_months) get no interpretation beyond their names.

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 standard and computation: 'ASC 340-40-25-4 practical expedient ... and full straight-line amortization schedules for longer-term capitalized incremental costs of obtaining a contract under ASC 606.' That is a concrete verb+resource and the ASC citation implicitly separates it from generic siblings like build_amortization_schedule or compute_deterministic_amortization_schedule, but no sibling is named outright, so it stops short of a 5.

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

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

It states the decision rule ('contract_term_months <= 12 -> expense immediately, apply_expedient=true') and a prerequisite ('Consumes upstream artifacts from: art-266-reconcile-commission-statement'), which implies when it applies. However there is no explicit when-to-use/when-not guidance and no named alternative among the many amortization-related siblings.

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

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

Annotations already cover the read-only, idempotent, non-destructive safety profile. The description adds meaningful context beyond that: compute routing behavior, transient processing with no storage/logging, browser delegation semantics, and AP2 artifact/execution_hash provenance. It does not cover rate limits or cost/access constraints, but the added behavioral detail 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 description contains useful purpose and behavior information, but it is bloated with repeated boilerplate, an external URL, and a lengthy FV-status snapshot explanation. The actual comparison summary appears mid-description rather than being front-loaded, reducing scan efficiency.

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

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

The description lists outputs and covers compute routing and AP2 artifact behavior, which helps for a complex compute node. However, for a tool with a nested policy_parameters object containing 18 required fields, the description does not adequately explain those inputs, and there is no output schema to carry return-value semantics.

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 is the primary source for parameter semantics. The description repeats the compute-mode behavior but does not explain the nested policy_parameters fields (dcType, lcType, risk inputs, fee inputs), which are only listed by name 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 names a specific comparison (Documentary Collections vs Letters of Credit cost-benefit) and identifies the decision context (trade transaction). The summary sentence lists the exact DC and LC variants being compared, which clearly distinguishes this tool from sibling LC-document validation or trade-rule tools.

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

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

The description implies the tool is used for trade-transaction cost/risk comparison and states that only synthetic or anonymised inputs should be used. However, it does not explicitly say when to use this tool instead of siblings such as examine_lc_document_presentation or check_digital_trade_rules, and no exclusions are given.

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

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

Annotations already cover the safety profile (readOnlyHint, idempotentHint, destructiveHint=false), yet the description adds real value beyond them: transient server-side processing with no storage or logging, a requirement to use synthetic/anonymised inputs, and the export of an AP2 artifact carrying execution_hash for chain provenance. It does not, however, describe what the computed result contains or how the browser delegation URL behaves in practice.

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 purpose is buried in a trailing 'Summary' sentence after several paragraphs of infrastructure boilerplate, a documentation URL, and an opaque FV-status hash path. Front-loading is poor and much of the text serves provenance/marketing rather than 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?

With no output schema, the description carries the burden of explaining what comes back, yet it only says an AP2 artifact with execution_hash is exported and defers to describe_tool and a web URL. For a financial decision tool with nine nested policy inputs, an agent cannot tell whether the result is a break-even price, a sell recommendation, or a quantified disposition outcome.

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 policy_parameters schema already enumerates shares, prices, dates, income and filing_status plus its required set, so the description does not need to restate parameter meaning. The description's compute-mode sentence duplicates the schema's own compute description rather than adding to it, 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 name and first line establish the domain (ESPP break-even and optimal sell analysis), but the only substantive sentence is the provenance note about porting 'ApexLogics Apex #110 (AL-117) ESPP Break-Even & Optimal Sell Analyzer'. The description never says what the analysis actually computes (break-even price? optimal sell timing? tax treatment?) and offers no explicit differentiation from siblings like compute_breakeven, model_scorp_break_even, or estimate_hdhp_ppo_breakeven.

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

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

There is no guidance on when to use this tool versus alternatives, no prerequisites, and no exclusions. The lengthy compute-mode discussion ('auto'/'server'/'browser') is about a transport parameter, not about when an agent should select this tool over another ESPP or break-even 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, so the bar is lower, yet the description adds substantive context: compute:"auto" runs server-side on Workers for gpu:false nodes with kernels, compute:"browser" returns a delegation URL instead of a result, and gpu:true nodes always delegate. It also discloses that inputs are transient and not stored or logged, plus that an AP2 artifact with execution_hash is exported for provenance.

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

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

The one genuinely useful sentence (what it analyzes, what it computes) is buried after a wall of platform boilerplate about compute binding and transient processing, followed by a 71-character FV-status hash URL and a 30-field output dump. Substantial text — the full hex digest, the "snapshot, not a subscription" disclaimer — earns no place for an agent deciding whether 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?

With no output schema present, the enumerated output field list does real work in telling the agent what comes back, and the compute-mode explanation covers the main non-obvious behavior. What's missing is any semantic gloss on the metrics (what break_even_probability or half_kelly_stake represent) and any statement of units or supported venues/modes, leaving an agent to infer meaning from bare field names.

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

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

Schema description coverage is 100%, so the schema already documents compute, parent_hashes, parent_tool_ids and the nested policy_parameters. The description only restates the compute-mode semantics and repeats the required-key list (forecast_prob, mode, no_ask, outcome, side, user_probability, venue, won) that the schema already enforces, adding no interpretation of what those keys mean or how they interact.

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

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

The description does state a specific verb and resource: "Analyzes a binary or scalar prediction market position" and enumerates the derived metrics (break_even_probability, kelly_fraction, brier_score, etc.). Sibling find_prediction_arbitrage is not named or contrasted, but the "/output feeds: art-212-prediction-market-arbitrage" line at least implies this is the single-position analytics step rather than an arbitrage scanner.

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 downstream routing ("Output feeds: art-212-prediction-market-arbitrage") and an input-safety constraint ("Use synthetic or anonymised inputs only"), which is real usage guidance. However, it never says when to pick this over find_prediction_arbitrage or any other market tool, and no preconditions beyond the input-hygiene note are 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, and the description adds real value beyond them: transient processing with no storage or logging, a synthetic-inputs-only constraint, export of an AP2 artifact with execution_hash for chain provenance, and the fact that the FV-status receipt verifies offline without fetching. The compute-mode explanation largely restates the schema, which caps this at 4 rather than 5.

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 actual purpose is buried at the very end behind a duplicated boilerplate header ('OpenChainGraph compute node... Deterministic OpenChainGraph compute node'), a compute-mode paragraph that repeats the schema verbatim, and a long FV-status paragraph containing a raw hash URL. Front-loading is poor and several sentences do not earn their place.

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

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

With no output schema, the description compensates by listing the returned fields (anchored, document_hash, document_type, timestamp_claim), the artifact exported, the downstream verifier, and the data-handling posture. That is enough for an agent to call it correctly, though the unspecified nested policy_parameters keys are a residual 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 coverage is 100%, so baseline is 3, but the description earns extra credit by explaining what the opaque policy_parameters object is for: binding document SHA-256, claimed timestamp, and the anchoring decision function. The nested keys themselves (hash_algorithm, document_type) remain undocumented anywhere, so it is not complete.

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 Summary states a specific verb and resource: bind a document SHA-256 plus claimed timestamp into an OCG execution_hash serving as an eIDAS Art.41/RFC 3161-aligned timestamp. That is concrete and distinguishable. It does not, however, differentiate itself from the sibling anchor_stamp, which sounds functionally adjacent.

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 names a downstream consumer ('Output feeds: art-122-timestamp-attestation-verifier') and instructs using synthetic/anonymised inputs, which is useful routing context. It never states when to prefer this over anchor_stamp, verify_timestamp_attestation, or verify_execution_hash, and gives no exclusions or prerequisites.

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

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

Adds substantial behavior beyond annotations: server-to-server vs. CORS relay, one upstream call per batch, RFC 6962 Merkle root anchoring, per-hash merkle_inclusion, independent equality re-verification before reporting success, and the exact failure payload {ok:false, unanchored:true, reason}. It also states it never fabricates a binding, which is critical trust context not conveyed by the hints.

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

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

The mechanics are front-loaded in the opening clause and the failure contract is stated compactly. It is dense, with nested parentheticals, but each clause carries information about anchoring, verification, or failure semantics, so little is wasted.

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

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

With no output schema, the description carries the return-shape burden and does so reasonably: success yields OCG v0.7 section 20 anchor_bindings entries, failure yields a fixed {ok, unanchored, reason} object. It does not detail the full binding structure, but for a two-param tool the key contract elements are present.

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

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

Schema coverage is 100%, so baseline is 3; the description goes further by explaining that an array triggers anchor_batch as a single upstream call with per-hash merkle_inclusion, and clarifies that authority mirrors anchor-suite's default rather than a hardcoded preference. That adds real meaning beyond the schema's field-level text.

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

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

States a specific verb (anchor/timestamp) and resource (execution_hash, single or batch array) and specifies the upstream path (anchor-suite MCP server, not the CORS-gated relay). This clearly distinguishes it from read-only siblings like verify_timestamp_attestation and verify_anchored_extract.

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 says 'Caller-invoked only; not wired into any automatic per-artifact-emission path', which tells the agent when the tool is appropriate versus automatic flows. It does not name a specific alternative sibling (e.g. a verification tool) as the way to check an existing binding, so it stops short of full routing guidance.

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

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

Annotations already cover read-only, idempotent, non-destructive, and closed-world behavior. The description adds useful operational context: it runs client-side with zero PII and zero network access, renders as a widget, and applies inputs via the AIN Bridge. It does not cover error behavior or execution limits, but it adds substantial behavior beyond the annotations.

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

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

The purpose is front-loaded, but the description repeats the client-side and zero-PII points, and the phrase 'agentic payment sy' appears truncated. The link and describe_tool pointer are useful, but the overall text could be tighter and more polished.

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

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

For a one-parameter read-only builder, the description gives enough context to understand that it produces a Policy Mandate JSON and runs client-side. However, it lacks detail about the expected input manifest and does not directly explain return values beyond pointing to describe_tool, leaving moderate gaps given the absence of an 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 inputs map is already documented in the schema. The description adds that inputs are applied via the AIN Bridge, but this mostly repeats the schema's explanation and does not provide additional element ID or value 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: translate AML/BSA program controls, transaction monitoring rules, and customer risk policy into a structured Policy Mandate JSON for agentic payments. This is meaningfully distinct from generic AP2 mandate tools, but it does not explicitly differentiate itself from siblings such as build_google_ap2_mandate or draft_ap2_mandate_credential.

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 that the tool is browser-based and client-side, and provides a link for interactive use, but it does not say when an agent should choose this tool over sibling AP2 mandate builders or validators. There are no explicit when-to-use, when-not-to-use, or alternative-routing instructions.

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

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

Annotations already cover read-only, idempotent, non-destructive, closed-world, but the description adds substantive behavior: server-vs-browser execution routing via registered kernels, transient/no-retention processing, 'use synthetic or anonymised inputs only', and AP2 provenance export with execution_hash. The remaining bulk is boilerplate (URL, FV-status hash blob) rather than further behavioral insight.

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 summary is buried mid-description after the title restatement, compute-mode boilerplate, and provenance chain text. The artifact URL and FV-status hash receipt take significant space without helping tool selection, though the descriptive content itself is substantive.

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

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

There is no output schema, and the description compensates by enumerating all returned fields (baseline_metric, delta_by_sector, stressed_metric, scenario_family, etc.), plus scenario inputs, privacy posture and chain provenance. It does not cover failure behavior or what is refused/'unknown keys are refused' beyond the schema 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 coverage is 100%, but the nested policy_parameters sub-properties (metric, scenario, exposures) are untyped empty objects in the schema, so the description's enumeration of scenario families and reference_version supplies meaning the schema genuinely lacks. The compute/parent_hashes semantics are mostly restated from the schema rather than extended.

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

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

States a specific verb and resource — 'Applies a climate scenario path ... to an exposure set' — and names the concrete scenario regimes (NGFS Phase V orderly/disorderly/hot-house, Fit-for-55, NGFS-Phase-V-2025) plus the emitted metrics. An agent can distinguish this from replay_supervisory_scenario or compute_stress_test_scenarios without opening the schema.

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

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

Gives clear operating context: compute mode selection rules ('auto' vs 'browser' vs gpu:true delegation), upstream artifacts to chain from (art-68-carbon-compliance-fit-diagnostic, art-71-cbam-certificate-cost-engine), and the down-stream consumer. It does not explicitly name a sibling alternative and state when that sibling should be preferred over this 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?

Annotations already cover the safety profile (readOnlyHint, idempotentHint, destructiveHint=false, openWorldHint=false), but the description adds genuine behavioral context: inputs are processed transiently and not stored/logged/retained, an AP2 artifact with execution_hash is emitted for chain provenance, and the compute mode determines whether execution is server-side on Cloudflare Workers or delegated to a browser URL. The FV-status receipt note explains offline verifiability, which is useful provenance information. It does not contradict the read-only annotation — the tool computes and exports, it does not mutate remote state.

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 not front-loaded: the tool's actual job appears in the last third, after a repeated 'compute node' framing, a Cloudflare Workers explanation that duplicates the compute enum, a 128-character FV-status URL and a bare documentation link. Several sentences ('OpenChainGraph compute node (compliance_mandate). Deterministic OpenChainGraph compute node.') are near-duplicates. An agent must read to the end to learn 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?

For a 4-parameter assembly tool with nested policy inputs and no output schema, the description covers what is missing elsewhere: the enumerated output fields (assembled_markdown, body_sha256, checks, cover_page_markdown, license, template_id), the upstream/downstream chain links, and the privacy posture. What it omits is small — e.g., what 'checks' contains or how the required policy_parameters keys must be expressed — but the agent has enough to call it correctly.

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

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

Top-level schema coverage is 100%, so compute, parent_hashes and parent_tool_ids are already documented — the description's restatement of compute modes adds little. But the nested policy_parameters object has ten properties with completely empty schemas, and the description is the only place that gives those keys domain meaning (training on customer data, non-training improvement, retention window, output ownership, AI sub-processor disclosure). That is meaningful compensation for the real gap 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 Summary sentence names a specific verb and artifact: assembling a Common Paper AI Addendum (Version 1.0) from Cover Page Key Terms, and enumerates the key terms involved (training on customer data, retention window, output ownership, AI sub-processor). It also places itself in the chain relative to art-412 procurement clause mapping and art-409 DPA checks, which distinguishes it from generic assembly siblings. The flaw is placement: the actual purpose sits after several paragraphs of compute/provenance boilerplate, so an agent skimming the first lines sees 'OpenChainGraph compute node' rather than 'assembles an AI addendum'.

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

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

Usage is implied rather than stated: the description declares upstream inputs come from art-412-ai-act-procurement-clause-mapper and the output feeds art-409-dpa-art28-completeness-checker, so an agent can infer where in a workflow this belongs. It also gives a hard input constraint ('Use synthetic or anonymised inputs only'). However, it never says when to choose this over near siblings like assemble_license_terms, assemble_mutual_nda, or map_ai_act_procurement_clauses, and gives no preconditions or exclusions.

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

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

Annotations already cover safety (readOnly, idempotent, non-destructive, closed-world), and the description adds genuinely new context on top: deterministic execution, transient processing with no storage/logging/retention, server vs browser delegation behavior, and an execution_hash-bearing AP2 artifact for chain provenance. Missing are failure modes (e.g. what happens on digest mismatch / version_mismatch) and any note on cost or delegation round-trip timing.

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 actual purpose is buried in a 'Summary:' fragment at the very end, behind duplicated boilerplate ('OpenChainGraph compute node (compliance_mandate). Deterministic OpenChainGraph compute node'), a marketing URL, and an FV-status hash URL. An agent must read past several sentences of platform scaffolding before learning what the tool produces.

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

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

For a complex tool with nested policy_parameters and no output schema, the description lists the return fields (aiuc1_version, anchor, cadence_attestation, controls, insufficient_evidence, oscal_assessment_results, pack_claim_strength, version_mismatch) and explains the compute path and chain position. The main remaining gap is guidance on the required nested inputs and expected failure conditions.

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

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

Schema description coverage is 100%, so the baseline is 3. The description restates the compute-mode semantics that the enum already documents, and hints that execution_hash values are what chain provenance (parent_hashes) consumes. It says nothing about parent_tool_ids ordering requirements or the relationship between control_mapping and cadence_period_days inside policy_parameters, so it adds little beyond the schema.

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

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

The 'Summary:' sentence gives a specific verb+resource: assembles a signed, AIUC-1 control-keyed evidence pack from execution receipts, escalation closures and work mandates, binding controls to artifact digests and exporting an OSCAL Assessment Results doc. Named upstream/downstream artifacts (art-303 linter, cry-05 aggregator, art-305 freshness lint) help place it against the many sibling *evidence_pack/assemble_* tools, though it never explicitly distinguishes itself from build_evidence_pack or assemble_ocg_evidence_bundle. The core purpose is only reached after a large block of platform boilerplate.

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

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

It states a usage constraint ('Use synthetic or anonymised inputs only') and explains the compute-mode decision (auto/server/browser, gpu:true always delegates), but that is operational guidance rather than when-to-use guidance. It never says when to pick this pack over the sibling evidence-pack assemblers, nor what prerequisites (which upstream artifacts must exist) are needed before calling.

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 behaviour, so the bar is lower, yet the description still adds real substance: deterministic server- or browser-side compute, transient processing with no storage or logging, a 'use synthetic or anonymised inputs only' constraint, and an exported AP2 artifact carrying execution_hash for provenance. It does not mention determinism failure modes or rate limits, but the safety and data-handling picture is well covered.

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

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

The text is long and inverted: boilerplate, a URL, and a 64-character FV-status hash dominate the opening while the single sentence that explains what the tool does sits at the very end. Most content does earn its place, but the hash and link block is noise for tool selection and could be moved or 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?

With four parameters, a nested policy_parameters object, and no output schema, the description compensates by enumerating the return fields (available_templates, checks, disclaimer, fields_missing, fields_used, rendered_html, rendered_text, template_id) and by naming upstream/downstream artifacts. An agent has essentially everything needed to call it and interpret the result; only a note on how fields versus template_id must line up 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 coverage is 100%, so baseline is 3; the description earns a step up by naming the concrete template values (CC-STANDARD-USE, IP3-RIGHTS-RECORD, NFT-EMBEDDED-LICENSE) that the otherwise unconstrained policy_parameters.template_id accepts, which lets an agent construct a valid call without probing. The parent_hashes/parent_tool_ids semantics are only in the schema, not elaborated here.

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 final 'Summary' sentence gives a specific verb and resource: renders a deterministic license term sheet by substituting field values into one of three named pre-approved templates. That is enough to distinguish it from siblings like check_license_compatibility or build_rights_record. However, the opening sentence is mostly boilerplate ('OpenChainGraph compute node (compliance_mandate)') and the actual purpose arrives last, so the read is not front-loaded.

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 paragraph tells the agent when to choose auto vs server vs browser, and the chain references (consumes art-204-license-compatibility-checker, feeds art-206-rights-record-builder) imply where this tool sits in a workflow. Those compute-mode rules are, however, nearly verbatim copies of the compute parameter's schema description, and the description never states when to pick this tool over a sibling such as select_embedded_license or certify_license_election.

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 real behavior beyond that: compute:'auto' runs server-side on Cloudflare Workers when a kernel is registered, compute:'browser' returns a delegation URL instead of a result, gpu:true nodes always delegate, and inputs are processed transiently with no storage or logging. That delegation-vs-result distinction materially changes what the caller gets back.

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 heavily padded with infrastructure and provenance boilerplate (Cloudflare Workers kernel registration, a full FV-status hash URL, an offline-verification aside, an exhaustive output key list) before reaching the actual purpose. The single most useful sentence — what the tool assembles — is buried in the final third, so the structure works against fast triage.

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?

Although there is no output schema, the description enumerates the returned fields (assembled_markdown, body_sha256, checks, contract_api, cover_page_markdown, attribution, license, zero_pii_notice), states the required key terms, notes the AP2 execution_hash provenance, and identifies the downstream consumer. For a deterministic composer this is close to complete; only the confidentiality/MNDA term-mode value conventions remain unexplained.

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

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

Schema description coverage is 100%, so the compute enum, parent_hashes/parent_tool_ids chaining fields, and the required policy_parameters keys are already documented in the schema, which sets the baseline at 3. The description contributes the mapping of 'Cover Page Key Terms' onto policy_parameters fields, but it does not clarify value formats, term-mode semantics, or what 'modifications' should contain.

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

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

The description does name the specific artifact and verb: assembles a Common Paper Mutual NDA (v1.0) from Cover Page Key Terms (purpose, effective date, MNDA term, confidentiality term, governing law/jurisdiction), which distinguishes it from generic siblings like assemble_license_terms or compile_work_mandate. The problem is placement: this core statement appears near the end after infrastructure boilerplate, so the tool's identity is not front-loaded.

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

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

There is no explicit when-to-use guidance and no named alternative among the many assemble_*/compile_* siblings. The only directive-like sentence is a data-handling constraint ('Use synthetic or anonymised inputs only'), which is a restriction, not a selection rule. 'Output feeds: art-277-agreement-acceptance-binder' faintly implies downstream chaining but does not tell 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/closed-world, and the description meaningfully adds beyond that: transient processing with no storage, logging or retention; server-side vs browser delegation semantics for GPU nodes; and that an AP2 artifact with execution_hash is exported for chain provenance. This is exactly the extra context the dimension rewards.

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

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

Wrong score placeholder

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

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

With a nested policy_parameters object, no output schema, and 100% schema coverage, the description does supply output field names and the tier definitions, so an agent can understand the return. But the truncated OCG-Prove clause and the noise (URL, FV-status hash, repeated boilerplate) leave the conceptual model incomplete.

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

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

Schema description coverage is 100%, so the compute modes and parent_hashes/parent_tool_ids chaining are already documented; the description only restates the compute modes. The listed 'Outputs' names are outputs, not inputs, so they add no parameter meaning. 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 does contain a specific verb+resource: 'Assembles a shareable evidence bundle around an artifact and stamps the ... tiered label it qualifies for' (OCG-Verify/Execute/Prove). However, that purpose statement is buried after several sentences of compute-node boilerplate, and the sentence defining OCG-Prove is truncated mid-word. It never differentiates from near-identical siblings like build_evidence_pack or assemble_aiuc1_evidence_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?

It gives a concrete input constraint ('Use synthetic or anonymised inputs only') and explains the compute:'auto' vs 'browser' vs gpu:true selection logic. It says nothing about when to choose this over the many sibling evidence-pack tools, which is the harder selection problem an agent faces.

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 behavior. The description adds meaningful context beyond that: server-side vs browser compute routing, forced browser delegation for gpu:true nodes, transient processing with no storage/logging/retention, AP2 artifact export with execution_hash, and upstream artifact consumption.

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

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

The description is bloated with a title restatement, a long compute-routing paragraph, an artifact URL, and a FV-status hash snapshot. The core purpose is not front-loaded, and several provenance details do not help an agent select 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?

No output schema exists, and the description does not explain the shape of the readiness result or how the assessment decision is represented. It does provide useful context on compute behavior, privacy handling, upstream artifacts, and AP2 export, but leaves the actual diagnostic output underspecified.

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

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

Schema description coverage is 100%, so the schema already explains compute, parent_hashes, parent_tool_ids, and policy_parameters. The description repeats compute-mode behavior and implies upstream chaining, but adds no detail about policy_parameters field names or required structure beyond pointing 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 description largely restates the title ("Agent Directory Publish Readiness Diagnostic") and calls itself an "OpenChainGraph compute node (compliance_mandate)" without stating what readiness criteria are assessed or what decision is produced. It never distinguishes this diagnostic from sibling readiness tools such as run_agentic_readiness_diagnostic or score_mcp_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 explicit when-to-use guidance, no when-not-to-use guidance, and no comparison to alternatives. The only usage constraint is "Use synthetic or anonymised inputs only," which is a data-handling rule 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 cover the safety profile (readOnly, idempotent, non-destructive, closed-world), and the description adds real substance beyond them: server-vs-browser compute routing with gpu:true always delegating, transient non-retained input handling, and an AP2 artifact export carrying execution_hash for chain provenance. It even names the downstream consumers and the FV-status receipt semantics.

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?

Core information (scope, compute semantics, data handling) is front-loaded and useful, but the definition is padded with a regulatory deadline aside, a long explanatory parenthetical, and a full FV-status hash URL that an agent gains little from at selection time.

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 well on provenance and privacy but leaves the actual decision surface opaque: nothing says what a conformity verdict looks like or which policy_parameters fields drive it. For a decision-function compute node with a free-form nested object, a bit more is warranted.

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

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

Schema description coverage is 100%, so the baseline is 3. The description restates the compute:auto/browser behavior already present in the schema and explicitly punts on policy_parameters ('See the tool's manifest for field names'), so it adds no field-level meaning for the one genuinely opaque parameter.

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 and opening line make clear this is an EU AI Act credit-scoring (Annex III Part 5(b)) conformity assessment node in the model_governance domain. It states the verb+resource, though it never explicitly says what artifact the assessment produces and offers no differentiation from neighbors like 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?

There is no when-to-use/when-not guidance and no routing to alternative sibling tools for AI Act conformity work. The only operational guidance is about compute modes and using synthetic inputs, which is invocation mechanics 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?

Substantially exceeds what the annotations provide: it explains the auto/server/browser compute resolution, that gpu:true nodes always delegate to the browser with a delegation URL returned, that inputs are processed transiently and not stored or logged, that only synthetic or anonymised inputs may be used, and that an AP2 artifact with execution_hash is exported for provenance. These are real operational constraints an agent could not infer from readOnlyHint/idempotentHint 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 two sentences are near-duplicates ('OpenChainGraph compute node (compliance_mandate). Deterministic OpenChainGraph compute node.'), and an inline FV-status SHA-256 hash plus a URL consume a large share of the text. The actual purpose, which matters most, is placed last 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 no output schema, the description compensates by enumerating the return fields (liability_allocation, dd_score_pct, diligence_grade, dd_gaps, etc.), and compute behavior and provenance are fully covered. The remaining gap is the shape of the nested policy_parameters.transaction input, which an agent must guess.

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; baseline is 3. The description adds only marginal parameter meaning — the upstream-artifact sentence hints at how parent_hashes/parent_tool_ids are sourced, but nothing explains the nested policy_parameters.transaction payload that drives the scoring decision.

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 Summary sentence states a concrete verb and object — scoring a transaction/contract config against the EU 20th-package no-Russia clause and anti-circumvention due diligence — and names the verdict type emitted. The upstream/downstream artifact references (art-94 classifier in, art-96 clause-pack builder and cry-04 out) also implicitly differentiate it from the sibling build_no_russia_clause_pack. The problem is that this is buried at the end of a long preamble.

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

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

Usage is only implied through the artifact chain: it consumes the ECCN dual-use classifier output and feeds two named downstream builders, which tells an agent roughly where it sits in a chain. There is no explicit 'use this when X, not Y' statement and no exclusions relative to siblings like build_no_russia_clause_pack or score_nis2_supply_chain_diligence.

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

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

Annotations already declare readOnly/idempotent/non-destructive/closed-world, and the description adds genuinely non-obvious behavior: the auto/server/browser compute binding, transient processing with no storage or logging, and an AP2 artifact export carrying execution_hash for chain provenance. It also discloses that 'Unknown keys are refused' at the parameter level and that the FV-status receipt verifies offline. Some of this is boilerplate shared across the node family, but it goes well beyond what annotations convey.

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

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

The description is dominated by reusable platform boilerplate — compute-mode explanation duplicated from the schema, a raw FV-status URL with a 64-character hash, and a 'call describe_tool(...)' pointer. The tool-specific content (one Summary sentence plus a criterion list) is at the very end 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 deterministic compute node with no output schema, the description supplies the decision criteria, the upstream artifact dependency, the exported artifact type, and the output field names (gaps, vuln_reporting_ready), which is enough for an agent to invoke and interpret it. What's missing is selecting-guide context relative to the many adjacent CRA and readiness 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 coverage is 100%, so all four parameters are already documented, including compute, parent_hashes, parent_tool_ids, and the nested policy_parameters object. The description's contribution is naming the five policy_parameters keys as assessment criteria, which helps interpret them but adds little syntax or format detail beyond the schema.

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

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

The Summary section states a concrete verb and compliance obligation ('Assesses EU CRA Article 14 vulnerability reporting readiness') and enumerates the five criteria it evaluates, which is enough to tell it apart from check_cra_annex1_completeness. However, the actual purpose is buried behind compute-binding and provenance boilerplate, so an agent must read to the end to learn what the tool does.

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

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

There is no when-to-use / when-not-to-use guidance and no named alternative among the dozens of sibling assess_* and check_cra_* tools. The only routing signal is 'Consumes upstream artifacts from: art-139-cra-annex1-completeness-checker', which describes a data dependency rather than 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, so the description carries a lighter burden, and it does add real context: inputs are processed transiently and not stored or logged, the call exports an AP2 artifact with an execution_hash for chain provenance, and compute mode changes where execution happens. It does not describe failure modes or latency, but the added disclosure is substantive.

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?

Large amounts of text are spent on repeated boilerplate ('OpenChainGraph compute node', stated twice), a duplicated compute-mode explanation already in the schema, a documentation URL, and a long FV-status hash URL. The one sentence that actually describes the tool arrives near the end, so the content is back-loaded 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 no output schema, listing the output fields (health_factor, liquidation_price_usd, buffer_to_liquidation_pct, health_status, liquidation_mechanism, etc.) does meaningful work in place of a schema. Privacy handling and provenance are covered, and the nested policy_parameters contract lives in the schema; only the meaning/units of ambiguous fields like health_status or buffer_to_liquidation_pct are left unstated.

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

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

Schema description coverage is 100%, so the schema already documents compute, parent_hashes, parent_tool_ids, and the policy_parameters object with its required keys. The description only restates the compute modes and never clarifies the semantics of protocol, collateral_amount, collateral_price_usd, or the distinction between collateral_value_usd and collateral_amount × price beyond what the schema implies. 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 Summary sentence gives a specific verb-and-resource: computes health factor, liquidation price, borrow capacity, and distance to liquidation, with the covered protocols named (Aave v3, Morpho Blue, Fluid, Sky/MakerDAO v2, Liquity v2). It is not differentiated from near-neighbours like assess_restaking_risk, compute_ltv_ratios, or model_perp_margin, and the operative sentence is buried under provenance boilerplate.

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

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

There is no statement of when to pick this over the many adjacent collateral/leverage tools in the sibling list, and no prerequisites or exclusions. The only quasi-guidance is the compute-mode explanation and 'use synthetic or anonymised inputs only', which are execution constraints 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 cover read-only, idempotent, non-destructive, and closed-world behavior. The description adds material behavior beyond annotations: deterministic server/browser compute binding, gpu delegation, transient processing with no storage/logging/retention, synthetic-input requirement, AP2 artifact export with execution_hash, and offline-verifiable FV status; there is no annotation contradiction.

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

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

The actual purpose summary is buried after repeated OpenChainGraph compute-node boilerplate, an external URL, and FV-status details. Several sentences are aimed at provenance/documentation rather than tool selection or invocation, and the description is not front-loaded.

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

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

For a complex nested compute tool with no output schema, the description covers compute modes, privacy behavior, provenance, module selection, and lists the output fields. It still lacks clear usage routing and deeper parameter semantics, but it is broadly complete for invocation.

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

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

Schema description coverage is 100%, so the baseline is 3. The description explains compute auto/browser/gpu behavior and mentions the two regime modules and supplied request list, but it adds little about parent_hashes, parent_tool_ids, or the nested policy_parameters beyond what the schema already documents.

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 late summary states the tool is a pack for regulatory exam management over an institution's own supplied request list, with two selectable regime modules and five stages, so the resource and scope are clear. It does not explicitly distinguish itself from the many sibling readiness/compliance assessment tools, and the leading compute-node boilerplate delays the core 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, when-not-to-use, or named alternative guidance. The summary implies the context (regulatory exam management over an institution's request list) and the compute enum implies mode selection, but an agent must infer when this tool is preferable to siblings such as other readiness diagnostics.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), and the description adds substantial context beyond them: server-vs-browser compute binding, transient non-retention of inputs, an 'use synthetic or anonymised inputs only' caution, and AP2 artifact export with execution_hash for provenance. No contradiction with readOnlyHint, since exporting a provenance receipt is not a data mutation.

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 substantive summary is front-loaded and specific, but it is padded with duplicated boilerplate ('OpenChainGraph compute node' stated twice), a long generic privacy/compute paragraph, and a raw FV-status receipt URL blob that is not needed to select or 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?

With no output schema, the description compensates by enumerating every returned field (clause_score, gaps, maturity_band, etc.) and pointing to describe_tool for the full schema, and it explains compute delegation and artifact chaining. For a 4-param nested-input tool this is nearly complete, short of explicit tool-selection guidance.

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

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

Schema coverage is 100% and each parameter is already documented, so the baseline is 3. The description's chaining note ('AP2 artifact with execution_hash for chain provenance') loosely ties to parent_hashes and it restates compute-mode behavior, but it adds nothing about policy_parameters/aims, the one required input.

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 summary states a specific verb and resource: assess ISO/IEC 42001 AIMS conformance across clauses 4-10 and six Annex A controls, naming each clause/control family. This is clearly distinct from siblings like assess_ai_act_conformity or check_gpai_code_conformance without opening any schema.

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

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

It names a downstream consumer ('Output feeds: art-172-ai-risk-impact-assessment-validator') and explains compute-mode selection, which implies where it sits in a chain, but it never states when to choose this over alternatives such as score_clause_coverage or assess_ai_act_conformity, nor any exclusions.

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

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

Annotations already declare readOnly/idempotent/non-destructive, so the description doesn't need to re-litigate safety, and instead adds genuinely useful traits: deterministic execution, server-vs-browser compute delegation, transient non-retained processing of inputs, and export of an AP2 artifact with execution_hash for provenance chaining. The only weakness is that the compute-mode paragraph largely restates the schema's `compute` field.

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 poorly front-loaded: title echo, compute-binding boilerplate, privacy note, a raw URL and an FV-status receipt path all precede the one sentence that says what the tool actually does. Several passages (compute mode, determinism) duplicate schema or sibling-wide boilerplate and do not earn their space.

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

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

It does list the output fields (arrangement_scores, composite_pct, gaps, stor_ready, surveillance_grade, etc.) and points to describe_tool for the full schema, plus covers privacy and provenance. The critical gap is that with zero required parameters the agent is never told which `policy_parameters` keys a kernel-backed compliance node accepts, beyond 'unknown keys are refused'.

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 explains compute modes and parent hash chaining at roughly the same depth as the schema already does, and it hints at the content of `policy_parameters` via the PPAET/STOR/insider-list/manipulation-pattern domains, but it never enumerates valid keys for that free-form object.

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

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

The 'Summary' sentence names a specific verb and resource: 'Scores market-abuse arrangements (Arts 86-92 + Dec-2024 RTS): PPAET, STOR templates, insider lists, manipulation-pattern config'. That is concrete enough to separate it from generic siblings like assess_mica_casp_readiness or run_mica_casp_fit. However, the actual purpose is buried at the end behind compute-node boilerplate, so an agent skimming the first sentences sees only 'OpenChainGraph compute node' rather than the function.

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

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

Usage is only implied: the description states it 'Consumes upstream artifacts from: art-98-mica-casp-fit-diagnostic' and its output 'feeds: cry-05-agent-action-audit-trail-aggregator', which positions it in a workflow. It also constrains inputs ('Use synthetic or anonymised inputs only'). But it never says when to pick this over sibling readiness assessors, and no exclusions are 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 cover read-only/idempotent/non-destructive, and the description adds genuinely non-obvious behaviour: server-side vs browser delegation, transient processing with no retention, AP2 export with execution_hash, and that the FV-status file is a snapshot receipt. The contribution is diluted by generic compute-node boilerplate, but the substance is there.

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

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

Front-loading is poor: the description opens with the title and a duplicated 'OpenChainGraph compute node' sentence, and the actual purpose only appears in the trailing Summary after compute-mode, data-retention, artifact-chaining, URL and FV-status text. Substantial boilerplate that does not earn its place for this tool.

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

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

The enumerated outputs and upstream/downstream artifacts compensate for the absent output schema, and the retention/compute notes are relevant. However, with a nested, largely untyped policy_parameters object and no input example, an agent still lacks enough to construct a correct call without consulting describe_tool.

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

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

Schema coverage is 100%, so the schema already documents all four parameters including policy_parameters and the compute enum. The description repeats the compute-mode semantics and the 'required: inputs' constraint without adding format or shape detail 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 Summary states a specific verb and resource – 'Scores readiness for MiCA CASP authorization (Arts 59-63)' – and enumerates the five scored dimensions. It is distinguishable from siblings such as run_mica_casp_fit or check_mica_reserve_disclosure, although it never names them or contrasts the scope.

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

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

'Use synthetic or anonymised inputs only' is a real usage constraint, and the upstream artifact IDs hint at prerequisites. But there is no when-to-use/when-not-use statement and no routing away from the near-duplicate mica fit tools that fill the sibling list.

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, the description discloses important behavioral traits: server-side vs browser compute modes, GPU delegation behavior, transient input processing with no storage or logging, AP2 artifact export with execution_hash, and the nature of the FV-status receipt as an offline-verifiable snapshot. These details materially help an agent understand execution and provenance.

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

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

The core purpose is buried near the end in a 'Summary' section behind repeated compute-node boilerplate, a URL, and a long FV-status hash. Several sentences, such as the offline-verification snapshot note and duplicated 'Deterministic OpenChainGraph compute node' phrasing, do not directly help an agent select 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?

For a complex compute tool with no output schema, the description does well by listing the output fields and explaining compute modes, privacy handling, upstream artifact consumption, and artifact export. The main remaining gap is the absence of explicit usage guidance versus sibling 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%, so the schema already carries the baseline documentation burden for all four parameters. The description adds domain meaning around the policy_parameters, especially tier, last_validation_date, outcome_status, and the overridable cadence, while compute mode behavior is also reiterated contextually.

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 specific operation: determining a model's SR 26-2 validation status by combining proportionality tier, last-validation date, and outcome-analysis result against a tier-based cadence. It also names the upstream artifact it consumes, which helps orient it in the chain, but it does not explicitly distinguish this tool from nearby siblings such as compute_eba_im_model_validation_tracker 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?

Usage is implied by the detailed purpose statement and the named upstream dependency, so an agent can infer this is for SR 26-2 model validation status checks. However, there is no explicit 'use this when...' guidance, no stated exclusions, and no direct routing to alternatives.

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

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

Annotations already cover readOnly/idempotent/non-destructive/closed-world, but the description adds real behavioral context beyond them: inputs are processed transiently and never stored or logged, compute:'browser' returns a delegation URL instead of a result, and the node emits an AP2 artifact carrying execution_hash for chain provenance. The FV-status receipt path further discloses that the provenance snapshot verifies offline. This is meaningful disclosure for a compute node whose execution location is non-obvious.

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 front-loaded with boilerplate that doesn't help selection or invocation: generic OpenChainGraph compute-binding prose, a privacy sentence, an AP2 export note, and a full FV-status URL plus hash. A roughly equal volume is spent on chain/compute plumbing as on anything about the assessment itself, and no purpose statement precedes the plumbing.

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

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

For a compliance-mandate assessment tool with a free-form policy_parameters object and no output schema, the description never explains what is assessed against NAIC AI systems expectations, what the result/report contains, or how to populate the decision-function inputs. It answers execution and provenance questions well but leaves the core 'what does this judge and what do I feed it' question unanswered.

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

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

Schema description coverage is 100%, so compute, parent_hashes and parent_tool_ids are fully documented in the schema; the description mainly repeats the compute-mode semantics. The critical gap is policy_parameters: the description only points at 'the tool's manifest for field names', so the agent has no way to know which assessment fields to supply for a free-form nested object.

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

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

The opening clause simply restates the tool name/title, and the body pivots immediately to OpenChainGraph infrastructure (compute modes, privacy, AP2 export) rather than saying what the assessment evaluates or how a NAIC AI-systems readiness verdict is produced. The one substantive hint is the upstream dependency on art-239-test-bifsg-bias-thresholds, which implies bias-threshold evidence is consumed. Against dozens of adjacent 'readiness/fit' siblings (run_insurance_reporting_fit, assess_iso42001_aims_conformance, run_ai_governance_fit), nothing distinguishes this one.

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 statement of when to call this versus the many other readiness/fit-assessment siblings, and no prerequisites or exclusions. The only usage-like instruction is the input constraint 'Use synthetic or anonymised inputs only', which constrains data handling rather than tool selection.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), and the description adds real value beyond them: deterministic compute, server-vs-browser execution routing, transient no-storage/no-logging data handling, and the AP2 artifact with execution_hash it exports for chain provenance. The compute-mode paragraph largely restates the schema enum, which is already at 100% coverage, so it is not fully additive.

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

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

The definition is poorly front-loaded: it leads with node-type restatement and compute-routing text duplicated from the schema, then includes FV-status receipt verbiage and a documentation URL before finally stating what the tool computes. The genuinely useful sentences (rubric summary, outputs, data-handling policy) are diluted by 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 no output schema, the description does the right thing by listing return fields (band, critical_gaps, domain_scores, overall_readiness_score, verdict). But for a tool requiring ten nested policy_parameters values, it never explains what those values should look like, which is the main risk for incorrect invocation; the AP2 export and privacy notes are good supplements.

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 domain list loosely maps onto the opaque policy_parameters keys (TPP categorisation → tppTypes, SCA exemption alignment → scaExemptions, fraud liability model → fraudLiability, embedded finance/BaaS → baasScope), which helps somewhat, but it never states accepted values or formats for those untyped properties.

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

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

The description names a specific verb+resource (PSD3/PSR readiness assessment) and enumerates the six rubric domains with article references (Art.35/36, Art.85–90, Art.59–65), which makes the scope unmistakable against siblings like run_mica_casp_fit or assess_ai_act_conformity. However, the actual purpose statement is buried at the end after node-type and compute-binding boilerplate, and no sibling is named explicitly for routing.

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

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

Usage is only implied by the deadline context (2027-06-01 transposition) and the instruction to use synthetic/anonymised inputs. There is no 'use this when / use X instead' guidance, no statement of prerequisites (e.g., which policy_parameters facts must be known before calling), and no exclusions relative to the many other readiness/fit tools.

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

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

Annotations already declare readOnly/idempotent/non-destructive, but the description adds real context beyond them: transient, non-logged, non-retained input processing; deterministic computation with an AP2 artifact and execution_hash for provenance; and the browser-delegation behaviour for gpu:true nodes. That is substantive disclosure for a compute node. It stops short of describing failure modes or what happens when required policy keys are missing.

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 structure is backwards: platform boilerplate and an FV-status URL with a long hash come first, and the one sentence that says what the tool does comes last. Roughly forty output field names are dumped inline in a single run-on list, most contributing no interpretable meaning. Every sentence does not earn its place.

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

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

There is no output schema, so the description must convey returns – it enumerates field names but never explains what the key ones mean (first_loss_tranche_pct, insurance_makes_sense, risk_reward_ratio). Data-handling and provenance are covered well. For a nested-parameter risk model, the description is adequate but leaves an agent guessing at output interpretation.

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 the eleven policy sub-fields. The description's compute-mode text largely restates the schema's own compute description, and it adds no meaning to policy_parameters such as first_loss_tranche_pct or insurance_premium_pct_of_rewards. Baseline 3 applies 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 'Summary' sentence gives a specific verb+resource: models restaking delegation rewards, operator fees, AVS yield and slashing-waterfall risk for EigenLayer and Symbiotic. That is enough to separate it from generic siblings like assess_defi_lending. It is not front-loaded, though – the purpose is buried after several sentences of platform boilerplate.

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

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

There is no statement of when to pick this tool over alternatives (assess_defi_lending, model_arc_cpn_economics, etc.), and no prerequisites or scenario framing. 'Use synthetic or anonymised inputs only' is a data-handling constraint, not usage guidance. The compute-mode hints are parameter-level behaviour already documented in the schema.

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

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

Annotations already declare readOnly/idempotent/non-destructive, so the bar is lower, and the description still adds real context: server-side vs browser delegation rules, transient non-retained input handling with a 'synthetic or anonymised inputs only' warning, and an AP2 artifact export carrying execution_hash for provenance. The compute-mode paragraph largely restates the schema's own compute description, which limits it from a 5.

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

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

The definition opens with a title restatement and two nearly identical 'deterministic OpenChainGraph compute node' sentences, then a compute-mode block, privacy note, provenance note, and an FV-status URL before reaching the actual purpose. The most useful information is last rather than front-loaded, and boilerplate occupies most of the text.

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

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

It lists the outputs (required_actions, status), the upstream artifact to chain from, and the provenance artifact, which is adequate for a 0-required-parameter compute node. However, the decision inputs in policy_parameters are left unexplained even though they are the substance of the suspect-vs-illegitimate determination, and there is no output schema to fall back on.

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 modes and never explains the policy_parameters keys (quarantined, fda_notified, verification_failed, identifier_unmatched, counterfeit_indicators) that drive the assessment, so it adds 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 'Summary' sentence names a specific verb and resource (determine suspect vs illegitimate product status under DSCSA) plus the concrete actions it triggers (quarantine, investigate, Form 3911, trading partner notice). It is clearly distinguishable from nearby siblings such as verify_saleable_return or verify_dscsa_transaction_statement, but the definition never says so, and the purpose is buried after a long preamble.

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 pick this tool over the DSCSA-related siblings or when not to use it. The compute-mode sentence describes execution modes, not selection guidance, and the upstream-artifact mention (art-113-saleable-returns-verifier) hints at sequencing without saying what to do with it.

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

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

Beyond the annotations, the description discloses deterministic execution, server-side versus browser delegation behavior, transient non-retention of inputs, synthetic-input requirements, AP2 artifact export with execution_hash, and FV-status provenance. This is substantial behavioral context, though the phrase 'Exports an AP2 artifact' is slightly ambiguous against readOnlyHint and the description does not discuss authorization or rate limits.

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

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

The description is long and cluttered with repeated compute-node boilerplate, an external URL, a raw FV-status hash, and an output-schema lookup instruction. The actual purpose appears near the end rather than being front-loaded, and several sentences do not help an agent select 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?

Given the absence of an output schema, the description usefully lists output fields and explains provenance/artifact behavior. Combined with rich annotations and full schema descriptions, it gives enough context to call the tool correctly, though it could be better organized around assessment semantics.

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

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

Schema description coverage is 100%, so the parameter baseline is 3. The prose explains compute modes and policy-parameter required keys, but those details are already present in the schema; the description adds little meaning beyond the structured parameter documentation.

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

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

The description states a specific verb and resource: it assesses Texas AI-deployment attributes and intentional-use assertions against TRAIGA/HB 149. The final summary makes the purpose clear, though the first several sentences are about compute-node mechanics rather than the assessment itself, and sibling differentiation is only indirect via the downstream safe-harbor pack builder.

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

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

Usage is implied by the name and by the statement that outputs feed the TRAIGA safe-harbor pack builder, but there is no explicit when-to-use, when-not-to-use, or alternative-tool guidance. The compute-mode guidance is useful for invocation but does not substitute for use-case 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 (which already declare readOnly/idempotent/non-destructive), the description adds meaningful traits: inputs processed transiently with no logging/retention, 'use synthetic or anonymised inputs only', an AP2 artifact with execution_hash for provenance, and gpu:true always delegating to browser. These are genuinely useful behavioral facts not covered by 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 is boilerplate-heavy, repeating the compute-mode explanation already in the schema, and pads with a long FV-status hash blob. The actual purpose of the assessment is never front-loaded or stated at all.

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

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

For a 4-param compute node with no output schema and a nested policy_parameters object, the description covers compute routing and provenance well but leaves the decision function and policy_parameters shape entirely undocumented, deferring 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 parameter meaning is largely carried by the schema. The description reinforces compute-mode behavior consistent with the enum but adds no syntax or format detail for policy_parameters, which remains opaque ('see 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 lead 'ViDA DRR Transaction Reporter: OpenChainGraph compute node (compliance_mandate)' restates the name/title and labels a category rather than saying what the tool actually assesses about DRR reporting obligations. Pipeline position (consumes art-159, feeds art-161) hints at a domain but never states the verb+resource outcome an agent would need to distinguish it from siblings like assess_vida_recapitulative_migration or run_vida_readiness_diagnostic.

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 statement of when to use this tool versus the many ViDA-adjacent siblings, and no prerequisites or exclusions. The upstream/downstream artifact references provide chaining context but not selection guidance.

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

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

Annotations already declare read-only, idempotent, non-destructive, closed-world behaviour and the description is consistent with them, while adding real context beyond them: deterministic execution, transient processing with no storage/logging, a synthetic-inputs-only constraint, and an AP2 artifact export carrying execution_hash for provenance. It also names the required upstream artifact (art-160-vida-drr-transaction-reporter), which is material for correct invocation.

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

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

Long stretches are generic node boilerplate (Cloudflare Workers, gpu:false kernels, AP2 export mechanics) plus a 64-character FV-status path that no agent needs in order to select the tool. 'Deterministic OpenChainGraph compute node' is said twice, and the front-loaded portion is title repetition rather than 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?

One of four parameters is an open-ended object whose fields are not described anywhere in the definition and there is no output schema, yet the description says nothing about what the assessment returns or what the compliance criteria are. It is complete on the compute/transport layer and largely silent on the decision layer that defines the 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 coverage is 100%, so the schema already documents compute, parent_hashes, parent_tool_ids and the shape of policy_parameters; the description only echoes the compute-mode semantics and the parent-hash chaining rather than adding to them. For policy_parameters it defers entirely to 'the tool's manifest for field names', leaving the actual decision inputs undisclosed.

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 verbatim ('ViDA Recapitulative Statement Migration Assessor: OpenChainGraph compute node') and never states what the assessment actually evaluates or produces. Nothing distinguishes it from close siblings such as assess_vida_drr_reporting_obligation, run_vida_readiness_diagnostic, or route_vida_oss_registration.

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 task-level guidance on when to run this assessor versus the other ViDA tools, nor any prerequisites. The only guidance offered is operational ('compute:"auto"' vs 'compute:"browser"'), which is transport mechanics, not usage selection.

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

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

Well beyond the annotations, it discloses that execution is deterministic, that gpu:false nodes run server-side on Cloudflare Workers unless compute:"browser" forces delegation, that inputs are processed transiently and not stored or logged, and that an AP2 artifact with execution_hash is exported for chain provenance. The note that the FV-status file is a snapshot that verifies offline is genuinely useful context. The compute paragraph largely restates the schema's own compute description, which tempers the score.

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

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

Purpose is not front-loaded; five sentences of generic compute-node, privacy, and artifact boilerplate precede the one useful Summary line. The compute-mode text duplicates the schema verbatim, and a full FV-status URL plus a 40-hex JSON path consume substantial space for a pointer. The 30-item output field dump is low-density compared to pointing at describe_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?

It covers what the tool decides, the compute/delegation model, retention behavior, and names the output fields, which compensates for the absent output schema reasonably well. However it never explains the decision logic an agent should expect — duplicate cluster detection, destination caps, roster movement — and the boilerplate crowds out anything about input semantics like duplicate_key_commitment_scheme.

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

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

Schema description coverage is 100%, and the schema already documents compute, parent_hashes, parent_tool_ids, and every policy_parameters key including the required list. The description adds no additional meaning about inputs — the long field enumeration describes outputs, not 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 summary sentence states a specific verb and resource: attests that a bulk payment run (salaries, pensions, social transfers, vendor payments) is internally consistent and matches its authorization. That is concrete enough to distinguish it from generic reconciliation siblings like attest_daily_reconciliation. It loses a point because the actual purpose is buried after several sentences of OpenChainGraph node boilerplate rather than stated up front.

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

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

The description implies the use case (verify a bulk payment batch before disbursement) but never states when to choose this over alternatives such as attest_daily_reconciliation or reconcile_report_to_general_ledger. The only explicit directives are operational constraints — 'Use synthetic or anonymised inputs only' and the compute-mode selection rules — not task-selection guidance.

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

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

Beyond the annotations, the description discloses substantive behavior: inputs are processed transiently and not stored, logged or retained; gpu:true nodes always delegate; a browser delegation URL is returned instead of a result under compute:'browser'; and the tool exports an AP2 artifact carrying execution_hash for chain provenance. That is real context the readOnly/idempotent hints do not convey, though pagination/rejection behavior is only implied by the 'rejected_inputs' output field.

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

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

The definition is dominated by repeated OCG platform boilerplate ('Deterministic OpenChainGraph compute node', the full hosting URL, a 64-character FV-status hash) that precedes the one sentence explaining what the tool does. The purpose sentence is also cut off, so the structure actively buries the load-bearing information.

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

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

For a zero-required-parameter attestation tool, the definition covers data-handling posture, compute routing, and enumerates the returned fields, which is reasonably complete given there is no output schema object. Gaps remain around when the tool is the right choice versus sibling independence checks and what a rejected/refused input produces.

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 parameter semantics are already fully documented, including the compute enum and the parent_hashes/parent_tool_ids chaining pair. The description adds the output field list (calc_agent_id, relationship_declaration, independence_asserted, rejected_inputs) but no extra meaning for the inputs themselves, 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 actual purpose only appears in the fifth sentence ('Receipts the organizational-independence claim a parametric trigger's neutrality depends on...'), after boilerplate about compute nodes and hosting URLs. It is specific about the resource (independence declaration of the entity whose kernel computed an art-251/252/309 execution_hash) but the sentence is truncated mid-clause ('or o...'), and no sibling (e.g. check_assessor_independence) is named for differentiation.

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

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

There is useful guidance on the compute modes ('auto' default, 'browser' forces delegation) and a data-handling instruction ('Use synthetic or anonymised inputs only'). What is absent is any statement of when to choose this tool over alternatives such as check_assessor_independence or other attest_* tools, and no preconditions are described.

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

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

Annotations already cover safety (readOnly, idempotent, non-destructive, closed-world), but the description adds valuable context beyond them: determinism, server vs browser execution behavior, transient input processing with no retention, a synthetic-data-only recommendation, and the AP2 artifact export with execution_hash. This is a rich behavioral profile for an attestation tool.

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

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

The description is somewhat bloated: it restates schema details, embeds a long URL and FV-status paragraph, and mixes compute mechanics with provenance notes. It is front-loaded with the tool's identity but could be tightened without losing actionable information.

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

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

For a 4-parameter compute node with no output schema, the description covers execution modes, privacy, and the artifact type, but it still leaves the core reconciliation logic opaque and defers parameter specifics to an external manifest. An agent can invoke it mechanically but lacks enough context to judge whether it is the right tool for a given reconciliation task.

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 thoroughly. The description repeats the compute-mode semantics from the schema and adds no extra detail for parent_hashes, parent_tool_ids, or policy_parameters, so it provides no meaningful value beyond the structured fields.

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

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

The description states the tool is a 'Daily Reconciliation Attestation' compute node that exports an AP2 artifact, but it does not explain what reconciliation is being attested or what the decision function does. It also fails to distinguish this from the many other attest_* and reconcile_* siblings, leaving the agent without a clear sense of its unique role.

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

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

The description gives no guidance on when to use this tool versus alternatives, no prerequisites, and no exclusions. It focuses entirely on compute-mode mechanics rather than selection criteria.

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

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

Goes well beyond the annotations: it discloses deterministic computation, the auto/server/browser compute binding behavior, that gpu:true nodes always delegate, that inputs are transient and neither stored nor logged, and that output is an AP2 artifact carrying execution_hash for provenance. That is meaningful operational context for a readOnly, idempotent tool. It stops short of describing latency, size limits, or failure modes.

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

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

The core purpose is front-loaded but is only a restated title; the body is dominated by infrastructure boilerplate and a long FV-status URL-plus-hash sentence that adds little for tool selection. Sentences are individually coherent, but the proportion of low-value content is high relative to the one or two useful claims.

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 should explain what inputs the decision function expects and what the result contains. Instead it points to an external manifest and an external spec URL, and substitutes output-schema coverage with a single line about the AP2 artifact. An agent still cannot construct a valid policy_parameters payload from this text.

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

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

Schema coverage is 100%, so the schema already documents compute, parent_hashes, parent_tool_ids, and policy_parameters; the description's compute-mode explanation duplicates the schema field text rather than adding to it. Critically, it defers policy_parameters content to "the tool's manifest," leaving the actual decision inputs unspecified in both places. Baseline 3 applies when the schema does the work.

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 purpose statement is the title restated ("Member Margin Call Lifecycle: OpenChainGraph compute node"), which is tautological. The text never says what the tool computes or attests about a margin call lifecycle, nor does it differentiate from siblings like mobilize_margin_collateral or compute_derivatives_margin_workbench. It does reveal the output is an AP2 artifact with execution_hash, which is the one informative detail.

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 and no named alternatives among a very dense sibling set. The only constraint offered ("Use synthetic or anonymised inputs only") is an input restriction, not a routing rule. An agent cannot infer from this description when to pick this tool over the many other margin-related tools.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false. The description adds rich behavioral context beyond that: compute modes (auto/server/browser), GPU delegation, transient processing with no storage/logging/retention, the synthetic-input requirement, and the export of an AP2 artifact with execution_hash for chain provenance. This is substantial disclosure that helps an agent understand side effects and data handling.

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

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

The description is bloated with boilerplate about OpenChainGraph compute nodes, FV-status links, and URLs. It is not front-loaded with the core purpose (which appears only in the final 'Summary' sentence) and includes many sentences that do not help an agent select 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?

Despite the verbosity, the description covers what an agent needs to call the tool correctly: compute mode behavior, data handling constraints, chaining prerequisites via parent_hashes/parent_tool_ids, and the exported artifact. It lacks an output schema but points to describe_tool for that, making it reasonably complete for a complex 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 input schema already fully documents all four parameters. The description mentions compute modes and chaining concepts but does not add meaning beyond what the schema provides for the parameters themselves. 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 explicitly states the verb and resource: 'Validates product/checkout/mandate JSON payloads against ACP or UCP field schemas (5 schema arrays).' This is a clear, specific purpose. However, it does not explicitly contrast with sibling tools like validate_acp_checkout or lint_ucp_checkout_payload, leaving the combined ACP+UCP scope to be inferred.

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

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

The description mentions upstream artifact consumption and downstream feeds, and says to use synthetic or anonymised inputs, but it provides no guidance on when to choose this tool over alternatives such as validate_acp_checkout or lint_ucp_checkout_payload. No exclusions or selection criteria are given.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive, and the description adds real context beyond them: inputs are processed transiently and not stored or logged, execution is deterministic, gpu:true nodes always delegate to the browser with a delegation URL, and the call exports an AP2 artifact carrying an execution_hash. The data-handling and delegation behaviour are exactly the kind of traits annotations cannot express. It stops short of describing failure modes or what the audit validates, which keeps it off a 5.

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

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

The text opens by restating the title, then pads with repeated framing ('OpenChainGraph compute node', 'Deterministic OpenChainGraph compute node'), a marketing URL, and a long FV-status hash with an offline-verification caveat. The genuinely useful facts — transient processing, synthetic inputs only, execution_hash export — are buried in the middle and compete with boilerplate. It is sized for a landing page, not a tool selection decision.

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 useful work by naming the AP2 artifact and execution_hash and pointing to the downstream consumer. However, the primary decision inputs live in an untyped policy_parameters object whose fields are never enumerated, and the tool's actual audit criteria are unstated, leaving an agent unable to construct a correct call without fetching the 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 compute, parent_hashes, and parent_tool_ids semantics are already fully documented in the schema, and the description's compute-mode passage merely restates them. For the open-ended policy_parameters object the description punts with 'See the tool's manifest for field names', adding no meaning. High coverage justifies the baseline 3, but the explicit deferral prevents anything higher.

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 resource (agent key rotation) and the verb (audit), but the description spends most of its words on platform mechanics — 'OpenChainGraph compute node', server vs browser execution — rather than saying what the audit actually evaluates or returns. An agent learns it is a 'deterministic compute node' in the 'compliance_mandate' category, which is a category label, not a purpose statement. It is distinguishable from siblings only by the name itself.

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

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

There is no statement of when to choose this tool over near-neighbours such as check_agent_token_scope, audit_mcp_tool_scope_revocation, or check_agent_attestation. The only directive is an input restriction ('Use synthetic or anonymised inputs only'), which is a constraint rather than usage guidance. 'Output feeds: art-133-agent-payment-rail-trust-crosswalk' hints at downstream chaining but never states a selection condition.

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

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

Annotations already declare readOnly/idempotent/non-destructive/closed-world, and the description adds genuinely useful behavior beyond that: determinism, server-side vs browser-delegation kernel semantics, that inputs are processed transiently and not stored or logged, and that an AP2 artifact with execution_hash is exported for provenance. The offline-verifiable receipt claim adds further context, though much of this is node-wide boilerplate rather than escrow-specific 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 definition opens with two paragraphs of generic OpenChainGraph boilerplate (compute binding, retention policy, link, FV-status hash URL) before reaching the one sentence that actually describes the tool, and even that sentence is cut off mid-clause ('one-sixth-...'). The long output-field dump then dominates, so the signal 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?

There is no output schema, but the description mitigates this by enumerating the verdict fields (shortage/surplus, cushion_cap, discrepancies, manual_review_required), so return values are largely covered. What's missing is the decision logic itself — the truncated cushion rule plus undefined threshold and course semantics — and any detail on the required policy_parameters value formats for a fairly complex, nested-input tool.

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

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

Schema description coverage is 100%, so the baseline is 3. The description's compute-mode text duplicates the schema's own compute description, and it says nothing about the shape of the nested policy_parameters payload (disbursements, monthly_payments, stated_balances arrays are unspecified even in the schema), leaving the most error-prone inputs undocumented.

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 Summary sentence gives a specific verb and resource (audits a servicer escrow accounting statement, recomputes running balances, compares stated end-of-month balances, checks cushion against the one-sixth cap), which is far more than a restatement of the name. However it is truncated mid-clause and never distinguishes this from siblings like compute_escrow_analysis or test_hpml_escrow, so an agent still can't rule out the near-duplicates.

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

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

Usage is only implicit: the summary indicates the tool applies when you have borrower-supplied escrow values (disbursements, stated balances, starting balance, monthly payments). The compute-mode paragraph explains server-vs-browser execution but that is parameter selection, not when-to-use guidance, and there is no exclusion or named alternative among the many escrow/servicing siblings.

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

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

Annotations already declare readOnly, idempotent, non-destructive and openWorld=false, so the safety profile is covered. The description adds genuinely non-derivable behavior: the tool renders as an interactive widget, runs client-side, uses the AIN Bridge for prefills, and involves zero PII and zero network traffic. It stops short of describing failure modes when inputs are missing, hence 4 not 5.

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

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

Three front-loaded sentences: capability, triggering context, then execution model and output discovery. Each sentence carries distinct information with no repetition, and the most decision-relevant content (what it audits) comes first.

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

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

For a read-only, client-side audit with no output schema, the description covers the safety profile, execution model, and where to obtain the input and output schema via describe_tool. The one gap is that an agent cannot invoke it meaningfully without a prior describe_tool call to learn the input element IDs, so it is disclosed but indirect rather than fully self-contained.

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

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

Schema coverage is 100% and the single 'inputs' parameter is an opaque map whose keys are not knowable from the schema itself. The description explains the delivery mechanism ('applied via AIN Bridge prefill') and points to describe_tool for the manifest input_schema, but does not list or characterize any of the expected input element IDs. Baseline 3 applies when the schema documents the parameter; the added pointer is marginal.

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

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

States a specific verb and resource ('Audit MCP OAuth 2.1 authorization') and enumerates the concrete checks: RFC 9728 protected-resource-metadata, RFC 8707 audience binding, and token-passthrough/confused-deputy risk. That is far more specific than a tautology, but it never distinguishes itself from nearby siblings such as validate_mcp_authorization_metadata, lint_mcp_server_conformance, or audit_mcp_tool_scope_revocation.

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

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

'Use when a developer is securing an MCP server's authorization' gives a real triggering context, which is better than nothing. It offers no exclusions and no routing to the many overlapping MCP-authorization siblings, so the agent must infer when this is preferred over validate_mcp_authorization_metadata or lint_mcp_server_conformance.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), yet the description adds genuine behavior: server-side vs browser delegation semantics for compute modes, gpu:true always delegating, transient non-retention of inputs, and an exported AP2 artifact carrying execution_hash for chain provenance. The FV-status receipt note is mostly boilerplate but does disclose that the trust snapshot is off-line verifiable rather than a live subscription.

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

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

The definition is not front-loaded: the actual purpose appears only in the 'Summary:' paragraph after compute-mode, retention, AP2-export, FV-status, and URL boilerplate that is largely identical across every tool in this family. Several sentences (the full compute:'auto'/'browser'/'gpu:true' explanation) duplicate the schema's own compute description, and the tool's specific payload is a minority of the text.

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, zero-required, read-only audit node with no output schema, the description is largely sufficient: it names the checks performed, the output fields, the compute/delegation behavior, and the provenance artifact. The gap is that it never says what a caller should supply for policy_parameters in a minimal call, but the business-level explanation of the fields covers most of that.

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

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

Schema coverage is 100%, so the baseline is 3, but the description goes past the schema: the nested policy_parameters keys have no property descriptions, and the description supplies their meaning — max token age versus elapsed time, next-key presence, and the https-scheme requirement on the revocation endpoint. It also names the output fields (audit_pass, revocable, rotation_ok, scopes_ok, token_age_s, ungated_tools), which compensates for the absent output 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 'Summary:' sentence states a specific verb+resource (audit MCP tool scope and revocation) and enumerates the concrete checks: explicit scope arrays, https-scheme revocation endpoint, and token rotation posture. It is clear what the tool does, but the statement arrives after ~600 characters of generic compute-node boilerplate, and nothing distinguishes it from close siblings such as audit_mcp_oauth, check_agent_token_scope, or lint_mcp_tool_definition.

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

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

Usage is only implied by the purpose: this is the auditor for scoped+revocable MCP tool grants. There is a real input constraint ('Use synthetic or anonymised inputs only') and routing context ('Output feeds: art-151-agent-obo-mandate-validator'), but no explicit when-to-use / when-not-to-use guidance and no named alternative among the many MCP-audit 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 readOnly/idempotent/non-destructive annotations, the description adds real behavioral facts: the node is deterministic, evaluation runs server-side on Cloudflare Workers unless compute is set to browser, inputs are not stored or logged, the authorization is one-use and window-clipped to the mandate expiry, and the request is re-verified at commit time. The FV-status line also clarifies that the receipt is an offline-verifiable snapshot rather than a subscription. The phrase 'issues a one-use authorization' slightly strains readOnlyHint, but because execution is stated as deterministic and non-persistent it is a computed output, not a stored side effect.

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 opens with redundant boilerplate ('Mandate Authorization Gate: OpenChainGraph compute node (payment_mandate). Deterministic OpenChainGraph compute node.'), buries the actual purpose in a trailing 'Summary:' section, and includes a long hex FV-status URL path that carries little selection value. The useful substance is there but it is not front-loaded, and the duplicate compute-node framing wastes the most valuable position.

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 enumerated output keys (authorization, decision, reasons, primary_reason, remaining_budget_minor, etc.) and the 'call describe_tool' pointer do reasonable work in describing the return. However, the description never explains the ten rules or the shape of the mandate and request objects, and it does not clarify how reasons vs domain_errors differ, leaving meaningful gaps for a decision tool whose whole value is the rule verdicts.

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 compute, parent_hashes, parent_tool_ids, and policy_parameters fields are already documented; the description only restates the compute auto/browser semantics that the schema already gives verbatim. It adds nothing about the nested mandate/request object shapes inside policy_parameters, which are opaque in both places, so it does not compensate for the one genuine gap.

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

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

The description names a specific verb and resource – an automated payment approval gate that runs a fixed ten-rule mandate check and issues a one-use authorization – which is far more informative than the title alone. It falls short of a 5 because it never positions itself against obvious siblings such as map_agent_payment_mandate, validate_ap2_mandate_chain, or build_google_ap2_mandate, so an agent has to infer which mandate tool is the right one.

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 only implied: it says inputs are processed transiently and 'use synthetic or anonymised inputs only', and mentions it consumes upstream artifacts from art-476-map-agent-payment-mandate, which hints at pipeline position. There is no explicit when-to-use/when-not-to-use statement and no named alternative for related mandate operations, so the agent must infer routing from the name.

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

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

Annotations already declare the tool read-only, idempotent, and non-destructive. The description adds valuable behavioral context beyond those: browser-based client-side execution, zero PII, zero network, widget rendering, and AIN Bridge prefill. It does not cover error handling or input constraints, so a 4 is appropriate.

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 and scope are front-loaded in the first sentence. The description is generally efficient but slightly redundant, repeating 'client-side' and 'zero PII' and spending two sentences on tool execution mechanics.

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

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

For a one-parameter tool with annotations and no output schema, the description covers purpose, outputs, execution environment, and points to describe_tool for the output schema. A gap remains around what happens when no inputs are supplied (default weighting behavior), but overall it is nearly complete.

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

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

Schema description coverage is 100%, and the single optional 'inputs' object is fully documented in the schema. The description only notes that inputs are applied via the AIN Bridge, which adds minor meaning but does not elaborate parameter-level details beyond the schema baseline.

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

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

States a specific verb ('score and compare') and resource ('BaaS providers') plus the exact dimensions and outputs. It does not explicitly differentiate itself from sibling comparison tools such as compare_agentic_payment_protocols, so it falls short of a 5.

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

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

The description implies the tool is for evaluating BaaS providers but gives no explicit when-to-use guidance, exclusions, or alternative tools. It never states conditions under which an agent should choose this over related comparators or scoring tools.

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

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

Beyond the read-only/idempotent/non-destructive annotations, the description discloses server-side versus browser compute behavior, GPU delegation, transient non-retention of inputs, export of an AP2 artifact with execution_hash, and upstream artifact consumption. These are substantive behavioral details that materially affect how an agent should invoke the tool.

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

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

The description is overlong and front-loads infrastructure boilerplate instead of the tool's purpose. It includes lengthy provenance/FV-status text and an incomplete 'Summary: OECD Transfer Pricing Guidelines Ch.' sentence that do not help an agent decide 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?

The description does provide compute behavior, data-handling context, provenance notes, and an output list, which is useful given nested parameters and no output schema. But it omits a clear explanation of what the benchmark computes and when it should be used, leaving an important semantic 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?

With schema description coverage at 100%, the schema already documents compute, parent_hashes, parent_tool_ids, and policy_parameters. The description's compute-mode explanation mirrors the schema and adds little extra parameter meaning, so the baseline of 3 is appropriate.

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

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

The description identifies this as a Transfer-Pricing Interquartile Range Benchmark and lists outputs such as iqr, median, q1/q3, and range_verdict, which hints at the computation. However, it never plainly states the core action, e.g. computing comparable-ratio quartiles and testing the tested-party ratio against an arm's-length range. The opening line restates the title and labels it a compute node, leaving the actual purpose 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?

There is no explicit when-to-use guidance and no comparison to any of the many sibling benchmark or compute tools. The only usage constraints given are 'Use synthetic or anonymised inputs only' and a mention of an upstream artifact consumer, which are operational constraints 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?

Beyond the annotations, it discloses deterministic compute behavior, server-vs-browser execution, transient processing with no storage/logging/retention, synthetic-input guidance, AP2 artifact export with execution_hash, and upstream provenance. These are substantial behavioral details and do not contradict readOnlyHint=true.

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

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

The purpose is buried after compute infrastructure, a long FV-status path, and repeated 'OpenChainGraph compute node' phrasing. Some boilerplate is provenance-relevant, but the definition is not front-loaded around the core action.

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

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

Despite having no output schema, the description lists the returned fields, explains the artifact/provenance model, covers compute routing and data handling, and references the upstream artifact. An agent has enough context to invoke it correctly.

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