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

Annotations already declare destructiveHint=true, idempotentHint=false, and readOnlyHint=false. The description adds only the 'within a draft' scope and implies upsert semantics via 'add or update', but says nothing about what an update overwrites, whether a version must exist, or any auth constraints — significant gaps for a destructive 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?

A single front-loaded sentence with no wasted words. It is tight and readable, though its brevity reflects under-specification rather than disciplined economy.

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

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

For a destructive 9-parameter mutation with 6 required fields and zero schema descriptions, one sentence is inadequate. The output schema exists so return values need not be explained, but the input contract and update semantics are left entirely 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?

With 9 parameters and 0% schema description coverage, the description carries the full burden of explaining inputs, yet it names none of them. Required fields like draft_id, version_id, author, summary, and identifier are entirely undocumented in both the schema and the description.

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

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

States a specific verb pair (add or update) and resource (key event), scoped to 'within a draft', which is concrete enough to act on. It does not, however, distinguish this from sibling tools like add_or_update_ker or get_key_event, leaving the agent to infer the distinction from names alone.

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

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

There is no when-to-use guidance, no prerequisite conditions, and no mention of the alternative add_or_update_ker. The agent is given no criteria for choosing this tool over its 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 a destructive, non-idempotent, write operation. The description adds only the draft scope and repeats the add/update action implied by the name, without explaining what gets overwritten, permission needs, or the effect on existing relationships.

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

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

A single front-loaded sentence with no wasted words. It is efficiently concise, though its brevity contributes to under-specification elsewhere.

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

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

For a destructive mutation tool with eleven parameters and many required domain fields, a one-line description is far too sparse. An output schema exists, so return values need not be covered, but parameter and behavioral context are missing.

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

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

Schema description coverage is 0% and the description provides no parameter semantics. Eleven parameters (seven required) including identifier, upstream, downstream, status, attributes, and provenance are left entirely unexplained.

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

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

The description states a specific action (add or update) and resource (key event relationship) scoped to a draft. It is clearly distinguishable from the sibling add_or_update_ke, though it does not explicitly name alternatives.

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 phrase 'within a draft' gives minimal implied context, but there is no guidance on when to prefer this tool over add_or_update_ke or list_kers, nor any prerequisites or exclusions. Usage must be inferred.

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 this a read-only, idempotent, non-destructive, closed-world operation, so the safety profile is covered. The description usefully adds that the output is a 'heuristic' (i.e., not authoritative) summary synthesized across three evidence levels, but says nothing about how evidence is gathered, what happens when evidence is missing, or determinism.

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

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

A single sentence with no filler, and the artifact being produced is front-loaded before the evidence scope. It is terse to the point of being dense with jargon, but every clause earns its place.

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

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

An output schema exists, so return values need not be explained, and annotations cover safety. However, for an analysis tool that depends on pre-existing evidence, the description omits what happens with incomplete evidence and how it relates to the sibling validation tool, leaving real gaps.

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

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

With a single parameter at 0% schema description coverage, the description must carry the load. It implies that the lone aop_id selects the AOP and that KE/KER-level evidence is collected internally rather than passed in, which is meaningful, but it never states what identifier format is expected or whether the AOP must be a draft.

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 (Build) and a specific artifact (an OECD-style heuristic confidence summary for an AOP), which is clearly distinct from data-retrieval siblings like get_evidence_matrix or get_aop. It does not explicitly contrast itself with the closest sibling, validate_draft_oecd, so an agent must infer the boundary between 'validate' and 'assess confidence'.

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

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

There is no statement of when to use this tool versus alternatives such as validate_draft_oecd or get_evidence_matrix, and no prerequisites or trigger conditions are given. The only implicit cue is that evidence must already exist at AOP/KE/KER level.

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

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

Annotations already declare readOnlyHint=false and destructiveHint=true, so the mutation profile is known. The description adds the prerequisite that the bundle must be 'validated' and that it lands in 'provenance', which is useful. It does not disclose what is overwritten, whether re-attaching is rejected (idempotentHint=false), or any permission needs.

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

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

A single front-loaded sentence with no filler, though it is dense with domain jargon ('aop_context', 'provenance'). Efficient, but minimal content given the tool's complexity.

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

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

An output schema exists, so return values need not be explained. However, for a destructive 5-parameter mutation with 0% schema coverage, the description omits the meaning of nearly every parameter and any usage context, leaving an agent under-informed about how to invoke it correctly.

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

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

Schema description coverage is 0% across 5 required parameters, so the description must carry the burden and largely fails. It obliquely references the bundle ('handoff bundle') and target draft, but says nothing about author, summary, draft_id, or version_id, leaving most parameters undocumented in both schema and 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 ('Attach') and a specific resource ('validated Registry aop_context handoff bundle') bound to a target ('draft's provenance'). Clear what it does, though it does not distinguish itself from siblings like review_registry_handoff_bundle or review_draft_bundle that touch the same handoff/bundle domain.

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 phrase 'for later review/export' hints at downstream purpose but gives no condition for choosing this tool over review_registry_handoff_bundle or save_draft_review_artifact. No prerequisites, no exclusions, no when-not-to-use guidance.

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

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

Annotations already declare destructiveHint=true, idempotentHint=false, and readOnlyHint=false, so the write/replace semantics are covered. The description adds nothing beyond 'draft' and 'write-path workflows' - it does not say what gets created or overwritten, whether draft_id must be unique, or any permission/validation requirement.

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

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

It is a single front-loaded sentence with no redundancy, which is structurally clean, but its brevity reflects under-specification rather than tightness. The 'write-path workflows' clause consumes space without earning it.

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

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

An output schema exists, so return values need not be explained. But for a 9-parameter creation tool with 0% parameter documentation, the description leaves critical gaps: what an 'AOP' draft requires, what adverse_outcome and applicability mean, and how this fits other draft-authoring siblings.

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?

There are 9 parameters with 0% schema description coverage (6 of them required), so the schema provides no meaning and the description must compensate. It mentions none of them - not draft_id, title, adverse_outcome, applicability, references, or tags - leaving an agent to guess at required content and formats.

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: create a new draft AOP. This distinguishes it from read siblings like get_aop and search_aops. However, the trailing phrase 'for write-path workflows' is vague jargon that adds little and does not differentiate it from other write siblings such as add_or_update_ke or save_draft_review_artifact.

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

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

No guidance on when to use this versus alternatives is given. 'Write-path workflows' is not a usable condition for selection, and no prerequisites, sequencing, or alternatives are named despite many sibling tools that touch drafts.

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 openWorldHint, so the safety profile is covered. The description adds genuinely useful behavior beyond that: it reaches out to CompTox for active chemicals, filters out already-curated AOP stressors, and returns results with diagnostics — meaningful context about data provenance and exclusion logic that annotations cannot convey.

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

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

A single dense sentence that front-loads the starting point ('one AOP's strongest assay candidates') and follows the pipeline in execution order. Every clause carries information; only the trailing 'with diagnostics' is slightly vague, but nothing 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?

An output schema exists, so the return shape need not be described. However, for a multi-step pipeline tool with five undocumented parameters and several near-identical siblings, the description leaves both the tuning knobs and the choice-of-tool question unresolved — adequate, but with clear gaps.

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

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

Schema description coverage is 0% for all five parameters, and the description names none of them: limit, assay_limit, min_hitcall, and per_assay_chemical_limit are never explained. The phrases 'strongest assay candidates' and 'active assay chemicals' only hint at thresholds, so an agent must guess what min_hitcall (default 0.9) or per_assay_chemical_limit actually control.

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

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

Names a specific verb (discover), the resource (orphan chemical stressors), and the scoping unit ('one AOP'), which cleanly separates it from the plural sibling discover_orphan_stressors_for_aops. The description also outlines the four-step pipeline (assay candidates → CompTox chemicals → exclusion → candidates with diagnostics), so an agent knows exactly what work it performs.

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 phrase 'Start from one AOP's strongest assay candidates' implies the trigger condition (you have a single AOP and want novel chemical candidates), but the description never states when not to use it or names the alternatives discover_orphan_stressors_for_aops and discover_orphan_stressors_for_query. Usage is inferable 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) and open-world behavior. The description adds genuinely useful semantics beyond that: exclusion of stressors curated anywhere in the selected AOP set, use of each pathway's strongest assay evidence, and cross-AOP support ranking.

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

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

A single dense sentence that front-loads the aggregation, then the exclusion rule, then the ranking criterion. No waste, though the run-on structure makes it harder to scan than two short sentences would.

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

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

An output schema exists, so return values need not be described, and the core pipeline semantics are present. However, for a 5-parameter tool with 0% schema coverage, the absence of any parameter-level guidance leaves the definition only marginally 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 0% across 5 parameters, so the description carries the full burden. It hints at the strongest-evidence threshold (relating to min_hitcall) and ranking/limits, but never explains min_hitcall, per_aop_limit, per_assay_chemical_limit, or limit, leaving four cutoffs undocumentable from the description.

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

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

Specific verb (aggregate) plus a well-defined resource (orphan chemical candidates across multiple AOPs), with the ranking basis stated. Implicitly distinguishes itself from the singular sibling discover_orphan_stressors_for_aop via 'across multiple AOPs', but never names that alternative explicitly.

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 mechanics (excluding curated stressors, combining strongest evidence per pathway) imply the use case — finding novel candidates not yet linked to the selected AOP set — but there is no explicit when-to-use/when-not statement and no named alternative versus the single-AOP variant.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, openWorldHint=true, and destructiveHint=false, so the safety profile is covered. The description usefully discloses the internal pipeline (search AOPs then aggregate across them) and that output includes per-AOP diagnostics, but adds nothing about cost, rate 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?

A single dense sentence that front-loads the input condition and the action sequence with no filler. It is well structured, though its brevity is partly under-specification rather than pure economy.

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

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

An output schema exists, so return values need not be described, but the definition is incomplete for a 7-parameter tool with 0% schema coverage and two near-duplicate siblings. The key information an agent needs, parameter meaning and which variant to choose, is missing.

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

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

Schema description coverage is 0% and the description mentions no parameter at all. Seven parameters, several cryptically named (min_hitcall, per_assay_chemical_limit, per_aop_limit, aop_limit vs search_limit vs limit), are left entirely unexplained, so an agent cannot infer their meaning or interaction from either source.

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 multi-step action (search AOPs, aggregate orphan chemical candidates, return diagnostics) triggered by a phenotype/mechanism query. It is clear about what the tool does, but it never differentiates itself from the closely named siblings discover_orphan_stressors_for_aops and discover_orphan_stressors_for_aop, which is the main ambiguity an agent faces.

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 sibling is named as an alternative. Given three near-identical 'discover_orphan_stressors_*' tools in the sibling list, the absence of routing guidance is a real gap; usage is only weakly implied by the 'query' input.

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, openWorldHint and non-destructive, so the safety profile is covered. The description adds the CSV/TSV output angle but says nothing about what 'aggregated' means, how the query and aop_ids paths interact, or any rate/size 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?

A single front-loaded sentence with no waste, but it is arguably too terse for an 8-parameter tool, so it stops just short of ideal.

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

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

For an 8-parameter, zero-description-coverage tool with several similarly named limit parameters, the description is far too thin. Although an output schema exists (so return values need no explanation), the input semantics and query-vs-aop_ids behavior are unaddressed.

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

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

Schema description coverage is 0% across 8 parameters, so the description must compensate and does not. It never explains limit, search_limit, aop_limit, per_aop_limit, or min_hitcall, leaving the multi-limit structure and the hitcall threshold entirely opaque; only 'CSV or TSV' loosely maps to the format enum.

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 (export) and resource (aggregated assay candidates) plus output formats, which cleanly distinguishes it from sibling exporters like export_draft_review_artifact and export_tool_call_audit_log_evidence. It does not explicitly name a sibling, 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 phrase 'from a query or explicit AOP list' implies the two input modes but gives no guidance on when to prefer one over the other, no prerequisites, and no exclusions relative to siblings like search_assays_for_key_event.

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, closed-world, so the safety profile is covered. The description adds real behavioral context beyond annotations: the output is a deterministic replay package bundling provenance integrity, Registry support, optional artifact verification, and recent audit records. It does not state format, size, or determinism mechanics, but it goes meaningfully beyond the structured 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?

A single front-loaded sentence with the core action first and details trailing. It is efficient and contains no filler, though the long comma-separated enumeration is dense.

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 six-parameter tool with an output schema, the description need not explain return values, and annotations cover safety. However, given the cluttered sibling namespace and 0% parameter documentation, it leaves gaps: no guidance on choosing between artifact_path and artifact_relative_path, no mention of the audit limit behavior, and no differentiation from adjacent export 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 0% for six parameters, so the schema supplies only names and types. The description references 'one draft version', 'artifact verification', and 'recent MCP audit records', which loosely maps to draft_id/version_id, artifact_path/artifact_relative_path, and audit_record_limit/include_audit_records. But it never explains the distinction between artifact_path and artifact_relative_path, the effect of audit_record_limit (including the 0-100 range), or the optional nature of version_id. With 0% schema coverage, the description should compensate more than it does.

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: export a deterministic replay package for one draft version. It enumerates what the package bundles (graph/provenance integrity, Registry support, optional saved artifact verification, recent MCP audit records). It does not explicitly name which sibling export tool (e.g., export_draft_review_artifact) it differs from, 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?

No statement of when to use this tool versus the many sibling export/review tools (export_draft_review_artifact, review_draft_bundle, export_tool_call_audit_log_evidence). There are no prerequisites or exclusions given. Usage must be inferred entirely 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 readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered by structured data. The description adds that it renders a 'unified draft review bundle' and supports an optional publication profile, which is useful context, but says nothing about auth needs, size limits, or side effects on the underlying draft.

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

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

A single front-loaded sentence that leads with the action and resource, with no filler. Slightly jargon-dense ('unified draft review bundle') but efficient overall.

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

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

An output schema exists, so return values need not be explained, but with 11 parameters at 0% schema coverage the description leaves most filtering/selection inputs undefined. For a multi-parameter export tool this is a meaningful completeness gap.

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

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

Schema description coverage is 0% across 11 parameters, so the description must carry parameter meaning and largely does not. It only loosely gestures at format (markdown/json) and artifact_profile (publication-style profile); identifiers (cas, dtxsid, inchikey, version_id), limits (assay_limit, min_hitcall, stressor_limit), and draft_id are left 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?

Names a specific verb (Export) and resource (draft review artifact) and clarifies it renders the unified draft review bundle in markdown or json. This is clear enough to distinguish it from save_draft_review_artifact and export_draft_replay_package, though it never explicitly names those siblings.

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

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

The description provides no when-to-use guidance, prerequisites, or exclusions relative to alternatives like save_draft_review_artifact, review_draft_bundle, or list_saved_draft_review_artifacts. Usage must be inferred from the name alone.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds useful behavioral context ('bounded', 'chain-verified'), but leaves unexplained what 'chain-verified' entails, where the package is written, or whether the durable log must exist.

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

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

A single, front-loaded sentence with no filler. It is efficient, though its brevity is in tension with the missing usage and parameter detail.

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

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

Because an output schema exists, return values needn't be explained, and annotations cover the safety profile. However, for a 4-parameter export tool with only 25% schema coverage, the description omits when-to-use routing and filter semantics, leaving real gaps.

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

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

Schema description coverage is only 25% – just audit_log_path is documented. The description adds no meaning for limit, status, or tool_name, and the low coverage means it should compensate but does not. An agent gets no hint about how these filters shape the export.

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

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

Names a specific verb (export) and resource (a bounded, chain-verified evidence package from the MCP tool-call audit JSONL log), with qualifiers that clarify the artifact type. It doesn't explicitly differentiate itself from siblings like list_tool_call_audit_records or verify_tool_call_audit_log, but the 'evidence package' framing is clear.

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

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

The description gives no when-to-use guidance or prerequisites, and does not mention the closely related siblings (list_tool_call_audit_records, verify_tool_call_audit_log) that an agent would need to choose between. Nothing tells the agent when this export is preferred over simply listing or verifying.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false, and a closed-world scope, so the safety profile is covered. The description adds the useful behavioral qualifier that paths are directed and confined to one AOP, but says nothing about traversal truncation, depth limits, or result exhaustion.

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

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

A single 13-word sentence with the scope qualifier front-loaded and zero filler. Nothing to trim.

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

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

An output schema exists, so return-value explanation is not needed, and annotations cover the safety profile. What remains missing is the meaning of max_depth and limit and any hint about path-count behavior, which matters for a traversal tool with five parameters.

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

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

Schema description coverage is 0%, so all five parameters are undocumented in the schema. The description clarifies the three required IDs implicitly but leaves limit (default 10, max 50) and max_depth (default 8, max 20) completely unexplained, and these are the non-obvious knobs for a graph traversal.

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 (find), resource (directed KE/KER paths), and endpoints (between two events) scoped to a single AOP. It is distinguishable from read-oriented siblings like get_ker and list_kers, though it never names an alternative tool explicitly.

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

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

The description gives no when-to-use guidance, no prerequisites, and no alternatives. An agent must infer from the name alone that this is the path-traversal option among siblings such as list_kers and get_ker.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered by structured data. The description adds only 'with metadata,' which hints at the return content but says nothing about auth, errors, or lookup behavior, so it adds modest value.

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

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

A single front-loaded sentence with no filler; every word (verb, cardinality, resource, payload hint) earns its place.

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

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

An output schema exists, so return values needn't be explained, and the annotations carry the safety profile. However, the parameter meaning and the distinction from search/list siblings remain unaddressed, leaving the definition only minimally sufficient for this low-complexity getter.

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

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

The single aop_id parameter has 0% schema description coverage and the description does not clarify its format, expected identifier scheme, or lookup behavior. With one undocumented parameter, the description fails to compensate for the coverage 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?

States a specific verb (Fetch) and resource (a single AOP) plus a hint at payload (metadata), so an agent can distinguish it from list/search siblings like search_aops. It stops short of explicitly naming those alternatives, so it earns 4 rather than 5.

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

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

The description gives no when-to-use guidance, no prerequisites, and never mentions the sibling it competes with (search_aops, get_related_aops). An agent must infer usage from the name alone.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false, and openWorldHint=false, so safety is covered. The description adds no behavioral context beyond a bare operation name — it does not explain what normalization does, how values are canonicalized, or any auth/rate-limit considerations.

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

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

The description is a single efficient sentence with no wasted words. However, its brevity comes at the cost of under-specification rather than purposeful 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?

An output schema exists, so return values need not be described. But for a tool with three undocumented parameters and no schema descriptions, the description should explain what normalization means and when to use it. The current text is too thin to guide 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 0%, so the description must carry the burden of explaining parameters. It merely lists the three field names ('species, sex, life stage'), which are already visible in the schema titles, and provides no format, allowed values, defaults, or normalization examples.

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

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

The description states a clear verb ('Normalize') and resource ('applicability parameters'), and names the specific fields involved. It distinguishes itself from the many AOP/assay siblings by operating on applicability normalization rather than retrieval or review, though it does not explicitly reference alternatives.

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

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

There is no guidance on when to call this tool, when not to, or what alternatives exist. The description implies it is a preprocessing step but never states that context directly.

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

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

Annotations already declare readOnly, idempotent, non-destructive, and open-world behavior, so the safety profile is covered. The description adds nothing beyond that — notably it never mentions that results are filtered by min_hitcall (default 0.9) or capped by limit, which materially affects what "assay candidates" means.

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 short and front-loads the action, but the second sentence repeats the first almost verbatim and earns little. Two sentences where one would have done, with no room saved for the missing parameter context.

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

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

An output schema exists so return values need no explanation, but the description still omits the meaning of min_hitcall and the result cap, and gives no differentiation among the many sibling assay-lookup tools. For a 3-parameter query tool at 0% schema coverage, this leaves real gaps.

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

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

Schema description coverage is 0%, so the description must carry the parameter burden. It implies aop_id is the input but says nothing about limit (default 25, max 100) or min_hitcall (default 0.9, 0-1), a threshold that silently filters results — a serious omission for an agent trying to interpret the output.

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 (return assay candidates for one AOP identifier), which is clear on its own. However, it does nothing to distinguish itself from near-identical siblings such as list_assays_for_aop, get_assays_for_aops, and list_assays_for_aops, so an agent cannot tell which one to pick from the description alone.

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

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

"Use this when you have an AOP ID and want assays" is essentially a restatement of the purpose rather than guidance. With four sibling tools covering the same AOP-to-assay mapping, the description gives no criteria, exclusions, or alternative routing.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false, so the safety profile is fully covered. The description adds only the notion of aggregation across multiple AOPs; it says nothing about how per_aop_limit or min_hitcall shape the result set.

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

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

Two short sentences with the core action front-loaded and no filler. Efficient, though it is lean to the point of omitting useful parameter detail.

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

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

An output schema exists, so return values need no explanation. But for a 4-parameter aggregation tool with 0% schema coverage, the parameters that control result breadth (per_aop_limit, min_hitcall, limit) are undocumented, leaving the definition materially 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 0% for 4 parameters. The description only implicitly covers aop_ids ('multiple AOP identifiers'); limit, per_aop_limit, and min_hitcall go entirely unexplained in both schema and description, leaving the agent no basis to set the hitcall threshold.

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 (return) and resource (aggregated assay candidates) scoped to multiple AOP identifiers. The word 'aggregated' plus 'multiple' implicitly separates it from the singular get_assays_for_aop, though it does not explicitly distinguish itself from the near-identical list_assays_for_aops sibling.

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 this when you have a list of AOP IDs' gives clear triggering context. However, siblings list_assays_for_aops and list_assays_for_aop are functionally close, and the description offers no exclusion or routing rule to pick between them.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered by structured data. The description adds nothing beyond that — no note on what a matrix contains, whether computation is deterministic, or expected input shape.

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?

One short sentence is technically concise, but here brevity reflects under-specification rather than economy. Nothing is front-loaded because there is essentially no content to front-load.

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

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

An output schema exists so return values need not be described, but the input contract is completely opaque and the description does nothing to compensate. For a tool whose only parameter is an undocumented array-of-objects, the definition is inadequate.

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

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

Schema description coverage is 0% and the single required parameter 'entries' is an array of objects with arbitrary string/null values, so the schema offers no semantic help. The phrase 'from KER facets' hints only weakly at what entries represent and does not describe structure, keys, or format.

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 ('Build an evidence matrix') but 'from KER facets' is unexplained domain jargon. It gives a rough sense of purpose but does not distinguish this tool from siblings or clarify what a KER facet is.

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 conditions. The agent must infer usage entirely from the name and the broader toolset.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so safety and repeatability are covered. The description's mention of plausibility, evidence, and quantitative-support text is response-content color, but since an output schema exists this is largely redundant and adds little behavioral context.

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

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

A single tight sentence that is front-loaded with the action and resource. Efficient, though the trailing list of returned fields is largely covered by the output schema and could be trimmed.

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

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

For a simple one-parameter read tool with full annotations and an output schema, the definition is minimally adequate. The notable gap is the unexplained ker_id parameter, which an agent must guess the format and source of.

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 0% and the single required parameter ker_id is never mentioned in the description. There is no indication of what form a ker_id takes or where to obtain one (e.g. from list_kers), so the description fails to compensate for the schema 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?

States a specific verb (Fetch) and resource (a single key event relationship), which implicitly distinguishes it from the plural list_kers sibling. It does not explicitly contrast with get_key_event or get_aop, so differentiation relies on the reader knowing the KER vs KE distinction.

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

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

No when-to-use guidance, no prerequisites, and no named alternatives. It never says when to reach for get_ker versus list_kers or the bulk KER-related siblings, leaving routing to inference.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, covering the safety profile. The description adds a small amount of context by mentioning 'OECD-style metadata fields,' hinting at the return content, but does not disclose any other behavioral traits such as error handling or authentication needs.

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

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

The description is a single, front-loaded sentence with no wasted words. It is appropriately sized for a simple retrieval tool.

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

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

An output schema exists, so return values need not be explained. However, the description fails to compensate for the complete lack of input parameter documentation and provides no usage context, making it incomplete for an agent to invoke the tool confidently.

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

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

Schema description coverage is 0%, and the description provides no information about the key_event_id parameter beyond implying it identifies a single event. It does not explain the ID format, source, or any constraints, leaving the parameter largely 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 description states a specific verb ('Fetch'), resource ('key event'), and scope ('single'), which distinguishes it from list_key_events and search_aops. However, it does not explicitly name or contrast with those siblings, so it falls short of the highest clarity tier.

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 offers no guidance on when to use this tool versus alternatives like list_key_events or get_ker. It only implies usage by mentioning a single fetch, but there are no explicit conditions, 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?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false, and openWorldHint=false, covering the safety profile. The description adds the relation mechanism (shared key events or KERs) which is useful behavioral context, but does not disclose pagination, rate limits, or other operational traits.

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?

One front-loaded sentence with no wasted words. It delivers the core purpose immediately.

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 relation-finding tool with full annotations and an output schema, the description covers purpose and mechanism. However, it lacks parameter guidance and explicit usage alternatives, making it minimally adequate but incomplete for correct invocation without inspecting other fields.

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 0% and the description does not mention any parameters. The aop_id is self-explanatory by name, but limit (default 20, min 1, max 100) is entirely undocumented in both schema and description, leaving a gap that the description fails to compensate for.

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 (Find) and resource (AOPs) plus the relation mechanism (shared key events or KERs). This distinguishes it from get_aop and search_aops, though no sibling is named explicitly.

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 phrase 'related to a source AOP through shared key events or KERs' implies the use case, but there is no explicit when-to-use guidance or comparison to alternatives like find_paths_between_events or get_aop. Usage is left to inference.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=true, and non-idempotent, so the agent knows this mutates state and that repeated calls may create duplicates or alter data. The description adds nothing beyond this – it doesn't explain what the link operation changes, whether it can overwrite existing links, or what permissions are required, despite this being a destructive write.

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

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

It is a single short sentence with no wasted words, but the extreme brevity here reflects under-specification rather than effective conciseness. It is front-loaded but says too little to be actionable.

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 9 parameters with no schema descriptions, a destructive non-idempotent mutation, and a crowded sibling toolset, the description is far too thin. While an output schema exists (so return-value explanation isn't needed), the lack of parameter clarification and usage context leaves critical gaps.

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

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

The schema has 9 parameters, 8 required, with 0% description coverage and no enums, so the schema gives no meaning for fields like 'label', 'source', 'target', or 'summary'. The description does not mention or clarify any parameter, leaving the agent unable to know what values to supply for these ambiguous required 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 'Link a stressor to a draft entity' is close to a restatement of the name and gives no detail about what a 'draft entity' is, what kind of link is created, or how it relates to the many sibling draft/review tools. It names a verb and two resources, but is too vague to distinguish this from numerous other draft-mutation tools.

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

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

There is no guidance on when to use this tool versus alternatives such as add_or_update_ke, attach_registry_handoff_to_draft, or create_draft_aop, nor any mention of prerequisites. The description offers no conditions or exclusions.

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

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

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so the safety profile is covered. The description adds genuine behavioral context beyond them: results are derived from linked stressor chemicals plus CompTox bioactivity, and empty results are accompanied by diagnostics rather than being silently empty. It stops short of describing pagination or the shape of those diagnostics.

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

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

A single dense sentence with the scope front-loaded and no filler. It is efficient, though the trailing 'with diagnostics explaining empty results' clause is slightly dangling and could be tightened.

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

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

An output schema exists, so return values need not be described, and annotations cover safety. The remaining gaps are meaningful: two of three parameters are undocumented anywhere and the crowded sibling space is not disambiguated, leaving an agent with open questions about both invocation and tool selection.

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 0%, so the description carries the full burden, and it does not deliver: limit and min_hitcall (a domain-specific hit-call threshold defaulting to 0.9) are never explained, and the bioactivity mention does not clarify what min_hitcall filters. Only aop_id is implicitly covered by 'for one AOP'.

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 (list) plus resource (assay candidates) and scope (one AOP), with the underlying mechanism named (linked stressor chemicals, CompTox bioactivity). The singular 'one AOP' implicitly separates it from the plural sibling list_assays_for_aops, but no sibling is named explicitly, so the agent must still infer the boundary against get_assays_for_aop and list_assays_for_query.

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 never states when to choose this over the many near-duplicate siblings (get_assays_for_aop, list_assays_for_aops, get_assays_for_aops, list_assays_for_query). It hints at context by scoping to 'one AOP' and mentioning empty-result diagnostics, but there is no explicit when-to-use, when-not, or alternative routing.

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

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

Annotations already declare readOnly/idempotent/openWorld/non-destructive, so the safety profile is covered. The description adds useful behavior beyond that (deduplication and per-AOP empty-result diagnostics), but omits how the min_hitcall threshold filters results, which is the operationally significant trait for this 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?

A single dense sentence with the aggregation behavior front-loaded and no filler. It earns its place, though the trailing 'with per-AOP diagnostics' clause could be integrated more tightly.

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

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

An output schema exists so return values need not be described, and annotations cover the safety profile. However, for a four-parameter aggregation tool with zero parameter documentation, the description leaves meaningful gaps around filtering and pagination behavior.

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 0% and the description explains none of the four parameters. It hints that aop_ids is a collection via 'multiple AOPs', but limit, min_hitcall, and per_aop_limit are undocumented in both schema and description, leaving an agent to guess their effect.

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 compound verb and resource: 'Aggregate and deduplicate assay candidates across multiple AOPs.' The 'across multiple AOPs' and 'deduplicate' framing differentiates it from the singular siblings list_assays_for_aop / get_assays_for_aop, though it never names them explicitly.

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 'across multiple AOPs' — an agent can infer this is for multi-AOP batch queries. There is no explicit when-to-use statement, no exclusion, and no named alternative (e.g. the singular list_assays_for_aop) to route between.

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, open-world, non-destructive, so the safety profile is covered. The description adds that results are aggregated across AOPs with query and per-AOP diagnostics, which is useful, but it discloses nothing about thresholding behavior (e.g., min_hitcall), limits, or what 'diagnostics' concretely 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?

A single front-loaded sentence that states input and output without padding. It is efficient, though a hint about parameter behavior would have been a worthwhile addition rather than a redundancy.

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

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

An output schema exists, so return values need not be described, but a six-parameter tool with a nontrivial threshold parameter (min_hitcall) is left with zero parameter documentation. For a multi-AOP aggregation tool the description is too thin to guide 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 0% across six parameters, and the description explains none of them. Non-obvious knobs like min_hitcall (a hitcall threshold), search_limit, aop_limit, and per_aop_limit are left entirely uninterpreted, so an agent cannot reason about their effect from either schema or description.

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

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

States a specific verb and resource (search AOPs from a phenotype/mechanism query, returning aggregated assay candidates) and hints at scope via 'aggregated' and 'per-AOP diagnostics'. The AOP-search framing implicitly separates it from per-AOP siblings, but no sibling is named to make the distinction explicit.

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

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

The trigger ('given a phenotype or mechanism query') implies when it applies, but there is no guidance on when to prefer this over list_assays_for_aop, list_assays_for_aops, or search_assays_for_key_event, and no stated prerequisites or exclusions.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, fully covering the safety profile. The description adds nothing beyond that – no note on result scope, pagination, or ordering – so it earns little credit beyond the structured hints.

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

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

A single front-loaded sentence with zero wasted words. It is efficient, though its brevity is partly under-specification rather than tight editing.

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

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

An output schema exists, so return values need not be explained, and annotations cover safety. For a simple one-parameter list tool the description is minimally adequate, but it omits usage guidance and any meaning for aop_id.

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 0% and there is one parameter (aop_id) that the description never explains. The AOP scope is inferable from the tool's purpose, but no format, source, or constraint for aop_id is provided anywhere.

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 (List), resource (key event relationships), and scope (for an AOP), which is enough to distinguish it from get_ker (single relationship) and add_or_update_ker (mutation). However, it does not explicitly name or contrast with those siblings, leaving the agent to infer the distinction.

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

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

There is no when-to-use guidance, no prerequisites, and no alternatives named. The usage is only implied by the verb 'List' and the AOP scope; the agent gets no help deciding between this and get_ker or add_or_update_ker.

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, so the safety profile is fully covered by structured data. The description adds nothing behavioral on top of that — no mention of ordering, completeness of the list, or whether it includes only accepted key events versus all key events.

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

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

A single front-loaded sentence with no filler, which is appropriately tight for a one-parameter listing tool. It is efficient, though its brevity is also part of what leaves the gaps noted elsewhere.

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

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

An output schema exists, so return values need not be described, and the read-only annotations cover safety. The minimum needed to invoke the tool correctly is present, but the absence of sibling differentiation and any parameter context leaves it only just adequate.

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

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

Schema description coverage is 0% and the single aop_id parameter carries no title-level explanation beyond 'Aop Id'. The description hints that aop_id scopes the listing to an AOP but adds no format, source, or lookup guidance to compensate for the coverage 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?

States a specific verb and resource ('List key events') and the scoping entity ('for an AOP'), so the agent knows exactly what it returns. It does not distinguish itself from siblings such as get_key_event or list_kers, which an agent could easily confuse for the same data.

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

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

There is no when-to-use guidance, no prerequisite or ordering note, and no named alternative. The description never explains how this differs from get_key_event or why an agent would call this instead of fetching a single key event.

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, so the safety profile is covered. The description adds that listing is scoped to the configured artifact output directory, but does not cover ordering, what happens when the directory is missing/empty, or result shape.

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

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

A single front-loaded sentence with the resource and scope stated before the optional filters. No filler.

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

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

An output schema exists, so return values need not be explained. For a read-only listing tool with annotations covering safety, the description is nearly complete; only the undocumented limit parameter keeps it short of fully 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 0%, but the description names the filter axes (draft, profile, format, subdirectory) that map to draft_id, artifact_profile, format and subdirectory. It leaves limit undocumented and gives no syntax or value hints, so it partially compensates for the schema 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?

States a specific verb (List) plus resource (saved local draft review artifacts) and scope (from the configured artifact output directory). It is clearly distinguishable from the mutating sibling save_draft_review_artifact and from export_draft_review_artifact.

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?

Describes what is listed and the available filters, implying the tool is for browsing previously saved artifacts. It does not state when to prefer this over save_draft_review_artifact or export_draft_review_artifact, nor any prerequisites for the configured directory.

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, closed-world, non-destructive behavior. Beyond that, the description adds meaningful context: records are 'process-local' and the response also includes durable audit persistence status, which distinguishes this view from persisted-log tooling. Return shape itself is deferred to the output schema.

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

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

A single sentence with zero filler, front-loading the verb and resource and appending the filters and persistence status. Nothing 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 an output schema present, return-value explanation is not required, and annotations cover the safety profile. The description covers scope, filters, and the persistence-status detail, leaving only the 'limit' parameter's meaning unaddressed.

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

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

Schema description coverage is 0%, so the description must compensate, and it only maps two of the three params ('tool-name and status filters') while saying nothing about the 'limit' parameter or its bounds (0-100). Types, defaults, and constraints are self-documenting in the schema, so baseline 3 is fair.

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 (List) and resource (MCP tool-call audit records) with clear scope ('recent', 'process-local') and names the two filters. It does not differentiate itself from the related audit siblings (export_tool_call_audit_log_evidence, verify_tool_call_audit_log), 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 description is purely declarative about what it returns; it offers no when-to-use framing, no prerequisites, and no mention of the sibling audit tools (export/verify) as alternatives. The agent must infer the use case entirely.

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, openWorldHint, and destructiveHint=false, so the safety profile is fully covered structurally. The description adds the input-type restriction (assay IDs, not AOP IDs), which is genuinely new behavioral context, but says nothing about result shape, cardinality, or lookup failure behavior.

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

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

Two short sentences, zero waste, with the core action stated first and the constraint second. Nothing is padded or repeated from the name.

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

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

An output schema exists, so return values need not be explained, and the description covers the input domain and its exclusion. It is essentially complete for a simple one-parameter read tool, missing only a note on what 'related' means or how many AOPs typically come back.

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 0% for the single parameter, so the description must carry the burden. It clarifies that the input is an assay identifier and warns against passing AOP IDs, which meaningfully constrains usage, but adds no format, prefix, or ID-syntax detail.

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

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

States a specific verb+resource: given an assay identifier, return related AOPs. This clearly distinguishes it from direction-reversed siblings like get_related_aops and from map_chemical_to_aops, though it does not name any sibling explicitly.

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 negative constraint 'Do not pass AOP IDs' implicitly routes the agent toward AOP-first tools for the reverse direction, which is useful. However, there is no positive statement of when to prefer this over list_assays_for_aop, get_assays_for_aop, or get_related_aops, so guidance is only implied.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=true, so the safety profile is fully covered. The description adds only the data sources and nothing about auth, rate limits, or result behavior, so it contributes little beyond 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?

A single front-loaded sentence with no filler. It is efficient, though its brevity is partly under-specification rather than disciplined 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?

An output schema exists so return values need no explanation. However, for a tool with two optional, undocumented parameters and silent routing against several sibling tools, the description is too thin to let an agent invoke it correctly without guessing.

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 0% and both parameters (cas, name) are undocumented in the schema. The description never mentions either parameter, so it fails to compensate for the coverage gap and gives no hint whether cas, name, or both are needed.

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 (map) and resource (chemical to related AOPs), and names the sources (AOP-DB, CompTox). It is distinguishable from the sibling map_assay_to_aops by resource, though it does not explicitly contrast with get_related_aops.

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 alternatives named. With siblings like get_related_aops and map_assay_to_aops in the same namespace, the agent gets no help choosing between them; usage is only inferable from the tool 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 readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false, so the safety profile is covered. The description usefully clarifies that this only BUILDS a payload rather than posting to Linear (reinforcing the 'plan_' prefix), which is meaningful behavioral context. It does not, however, explain the live-export vs saved-artifact resolution behavior or any 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?

A single, front-loaded sentence with no filler. It is efficient in form, though that efficiency borders on under-specification for a 15-parameter tool. No structural problems.

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 15-parameter tool with zero schema coverage, no required-parameter guidance, and no explanation of how the two input-source modes map to specific fields, the description is far too thin. An output schema exists so return values needn't be described, but the input side is badly under-documented.

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 15 parameters and 0% schema description coverage, the schema provides titles only and the description adds no parameter meaning whatsoever. Critical parameters like artifact_path, artifact_relative_path, artifact_profile, cas, dtxsid, inchikey, and the hitcall/stressor_limit tuning knobs are entirely unexplained. This is a substantial gap the description should have compensated for.

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 artifact: 'Build a connector-ready Linear document payload.' The dual source (live draft review export vs saved artifact) is named, which is informative. However, it does not distinguish itself from sibling export/save tools like export_draft_review_artifact or save_draft_review_artifact, leaving the agent to infer the boundary.

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 two input modes but gives no guidance on when to choose one over the other, nor when this planning step should be used versus the many adjacent export/artifact siblings. No prerequisites, no exclusions. Usage must be inferred entirely.

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, openWorldHint and destructiveHint=false, so the safety profile is covered. The description adds useful context that the tool aggregates three distinct external data sources (draft stressor links, KE assay candidates, CompTox bioactivity cutoffs), consistent with openWorldHint, but says nothing about cost, latency, 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?

A single front-loaded sentence with no filler; the purpose leads immediately. It is somewhat dense with domain jargon but nothing 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?

An output schema exists, so return values need no explanation, and the description conveys the conceptual inputs. However, for a five-parameter review tool with zero schema descriptions and no usage routing among many review siblings, the definition is only minimally 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 0%, so all five parameters (draft_id, version_id, assay_limit, min_hitcall, stressor_limit) are undocumented. The description mentions concepts like assay candidates and stressor links but never maps them to the limit/threshold parameters, so it fails to compensate for the coverage 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?

States a specific verb ('Review') and a precise resource ('per-KER assay-cutoff ordering evidence for a draft'), and even enumerates the inputs it combines (draft stressor links, KE assay candidates, CompTox bioactivity cutoffs). It is distinguishable from generic siblings like review_draft_bundle or review_draft_evidence_gaps, though it never names them explicitly.

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, or alternative-selection guidance. The description explains what the tool composes but not when an agent should reach for this review tool over the many other review_* 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 readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. The description adds that this is a composite bundle and that chemical projection is optional, which is useful scope context, but it discloses nothing about cost, response size, or what 'chemical projection' entails.

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

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

A single front-loaded sentence that names the resource first and lists the components without filler. Slightly dense, but every clause earns its place in conveying what the bundle contains.

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

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

An output schema exists, so return values need not be described, but with 9 parameters at 0% schema coverage and no usage guidance, the definition is under-specified for a tool this broad. Critical inputs like assay_limit, min_hitcall, stressor_limit, and the draft/version identifiers are never explained.

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 0% across 9 parameters, so the description carries the full burden. It only hints at chemical projection (loosely tied to cas/name/dtxsid/inchikey) and says nothing about draft_id, version_id, assay_limit, min_hitcall, or stressor_limit, leaving most parameters semantically opaque.

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 ('Build') and resource ('unified draft review bundle') and enumerates the four components it aggregates (validation, evidence-gap findings, per-KER assay-cutoff ordering, chemical projection). The enumeration maps onto sibling tools like review_draft_evidence_gaps and review_draft_assay_cutoff_ordering, so an agent can infer the aggregate nature, though those siblings are never named explicitly.

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 alternative guidance. The phrase 'combines ... into one response' only weakly implies this is a convenience wrapper over the individual review tools; the agent is left to infer that it should prefer this over calling the specialized siblings separately.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false, and openWorldHint, so the safety profile is fully covered structurally and there is no contradiction. The description adds only the scope of what is mined, with nothing about cost, rate limits, or result shape; with annotations carrying the behavioral load, this is an adequate but unremarkable 3.

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

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

A single dense sentence with the verb front-loaded and no filler. It is jargon-heavy but every clause earns its place by naming a gap category.

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

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

An output schema exists so return values need not be explained, and annotations cover the safety profile. However, for a five-parameter tool with zero schema coverage, the description leaves the agent without any guidance on parameter behavior or when this review should be run relative to sibling review 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 0% and none of the five parameters (version_id, assay_limit, min_hitcall, stressor_limit) are explained in the description. Only draft_id is obliquely implied by 'one draft', leaving the tuning parameters completely undocumented in prose.

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

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

The description gives a specific verb ('mine') tied to a resource ('one draft') and enumerates the five dimensions of gaps it surfaces (root metadata, topology, KE assay coverage, KER evidence fields, stressor resolvability). It is clearly distinguishable from sibling tools like validate_draft_oecd or review_draft_bundle in intent, though it never explicitly contrasts itself with those siblings.

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

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

There is no statement of when to use this tool versus alternatives such as review_draft_bundle, review_draft_assay_cutoff_ordering, or validate_draft_oecd, and no prerequisites or exclusions. Usage is only loosely implied by 'one draft' and the gap-analysis framing.

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

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

The annotations already declare readOnlyHint=true, idempotentHint=true, openWorldHint=false, and destructiveHint=false, so the full safety profile is covered structurally. The description adds only the output intent ('bounded-use import guidance'), and says nothing extra about validation failure modes or what 'bounded-use' actually constrains.

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

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

A single sentence that front-loads the action and states the output goal, with no filler. It is dense with domain jargon but wastes no words.

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

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

An output schema exists, so return values need not be explained, and the annotations fully cover behavior. However, for a tool whose sole input is a nested freeform object at 0% schema coverage, the description does not provide enough guidance 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?

There is one parameter with 0% schema description coverage; the schema types it only as a freeform object with additionalProperties=true. The description names the concept ('Registry aop_context handoff bundle') but gives no indication of the expected fields or shape, so an agent has almost nothing to construct a valid bundle from.

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 ('Review') and resource ('Registry aop_context handoff bundle') and clarifies the output ('bounded-use import guidance for AOP draft review'). It distinguishes itself from attach_registry_handoff_to_draft by reviewing rather than attaching, but the jargon-heavy noun phrase leaves the actual subject matter somewhat opaque.

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