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

The description discloses the exact failure behavior ('returns error code unsupported (E3)') and the fact that cancellation is not implemented. This goes beyond the annotations, which only say readOnlyHint=false and destructiveHint=false; the description clarifies that the tool is a stub and what an agent should expect.

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 main action front-loaded and the implementation caveat immediately after. No filler or redundant restatement of the schema.

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

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

For a one-parameter stub with an output schema, the description is nearly complete: it states purpose, non-implementation, and exact error code. The only gap is that transfer_id semantics are left to inference, which is minor for such a simple parameter.

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 provides only a type and title for transfer_id with 0% description coverage, so the description needed to compensate. It implies that transfer_id identifies the running transfer, but does not explain its format, source, or what makes a transfer 'running'. This is minimal added meaning beyond the schema.

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

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

The description uses the specific verb 'Cancel' with the resource 'a running transfer', clearly identifying the operation. It also explicitly states the tool is not implemented in this build, which is a distinct, unambiguous qualification. The name alone could be ambiguous about whether it lists or cancels transfers, but the description resolves this.

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

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

The description gives clear context: it is meant for canceling a running transfer, and it explicitly states that it is not implemented and will return error 'unsupported' (E3). This effectively tells an agent not to rely on it, although it does not name a sibling alternative.

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

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

The description goes beyond the annotations (readOnlyHint: true, openWorldHint: true) by explicitly disclosing that the tool returns an 'unsupported' error in this build. This is critical behavioral information that prevents an agent from wasting time attempting a call. It is consistent with the readOnlyHint (a compare operation is read-only) and adds the key fact that the tool is non-functional.

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 exactly two sentences: the first states the purpose, the second the implementation status. Both sentences carry essential information with zero fluff, and the most important caveat is placed right after the purpose. This is an appropriately sized and well-structured description.

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

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

For a tool that is not implemented, the description is nearly complete: it tells the agent the tool will fail and why. It does not need to explain return values since an output schema exists and the tool is non-functional. However, it omits any hint of which sibling tools could serve as substitutes, which would make it fully complete. Given the tool's unsupported status, the missing alternative guidance is a minor 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 only 20% (only max_records has a description), and the tool description does not explain any of the parameters. It does not compensate for the undocumented files, samples, interval, or reference parameters. While nested types like FileRef and Interval have rich descriptions in the schema, the top-level parameters remain semantically opaque, and the description adds no parameter-level value.

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

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

The description clearly states the tool's function: 'Compare genotypes/coverage at an interval across files or samples.' This uses a specific verb ('Compare') and resource ('genotypes/coverage at an interval'), and is easily distinguished from sibling tools like get_coverage or get_variants, which retrieve single-file data rather than perform cross-sample comparisons. The additional note that it is not implemented further sharpens the purpose by setting expectations.

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

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

The description gives explicit guidance that the tool is not implemented and will return error code 'unsupported' (E9), which effectively tells agents not to use it. However, it does not name alternative tools for comparison tasks, such as get_coverage or get_variants, leaving the agent to infer alternatives from the sibling list. Still, the 'not implemented' warning is a strong and clear usage directive.

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

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

Annotations already mark the tool as read-only and open-world, and the description adds a crucial behavioral detail beyond those: the tool is non-functional and returns error code 'unsupported' (E6, E7). This does not contradict the annotations.

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

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

The description is two sentences with no filler. It front-loads the purpose and directly states the critical unsupported behavior, making every sentence earn its place.

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

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

The unsupported status and presence of an output schema cover important ground, but the description omits parameter semantics and does not suggest an alternative tool. For a tool with two required parameters and zero schema-level parameter descriptions, this is a noticeable 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%, so the description must compensate, but it only mentions 'native accession' and never explains the 'source' or 'accession' parameters. An agent cannot determine what values to provide for these 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 states a clear action ('Describe') and target ('study/dataset by native accession, with linked entities'), which distinguishes it from search/list siblings by indicating an accession-based lookup. However, 'native accession' is not defined, leaving some ambiguity about exactly what source and accession mean.

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

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

The description explicitly warns that the tool is not implemented in this build and will return an 'unsupported' error, which is a clear when-not-to-use signal. It does not name an alternative tool to use instead, so it stops short of full routing guidance.

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

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

Annotations already indicate this is a write-like operation (readOnlyHint=false) and not destructive (destructiveHint=false). The description adds valuable behavioral context: it is a bounded download, returns a transfer job, requires budget_bytes for large files, and is not implemented in this build (returns E3). This goes beyond the annotations and helps the agent set expectations.

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 sentences, front-loaded with the core action and return type, then the budget_bytes caveat and the not-implemented warning. No wasted words. It could be slightly more structured, but it is efficient and readable.

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

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

Given the output schema exists and the annotations cover safety, the description is fairly complete: it states the action, the return type, the budget_bytes condition, and the unsupported status. It does not explain what a transfer job is or how to poll it, but sibling tools get_transfer_status and cancel_transfer exist, so the context is inferable. The missing parameter semantics for include_index and verify_checksum are minor 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 compensate. It mentions budget_bytes and the file+index concept, but does not explain the other parameters (include_index, verify_checksum) or the FileRef fields. The description adds some meaning (bounded download, budget_bytes) but leaves most parameter semantics to the schema, which has no descriptions for the top-level parameters.

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

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

The description states a specific verb ('Start a bounded download') and resource ('a file (and index) to the local work dir'), and distinguishes it from sibling read tools by noting it returns a transfer job. It is clear but does not explicitly name a sibling alternative, so it loses a point for differentiation.

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

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

The description gives clear context: it is for bounded downloads, and files above the default limit need budget_bytes. It also warns that the tool is not implemented in this build and returns error code 'unsupported' (E3). It does not explicitly say when to use an alternative like get_reads or get_sequence, but the transfer-job framing implies it is for materializing files rather than streaming data.

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

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

Beyond the readOnlyHint annotation, the description discloses that the tool is not implemented in this build and will return a specific error. It also explains the default read filtering, a behavioral trait not visible from the schema alone.

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

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

Two sentences deliver the essential purpose, filtering semantics, and the critical not-implemented warning without wasted words. The most important operational fact—that it returns unsupported—is clearly placed at the end.

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

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

The description is adequate for a tool that currently cannot execute: it states the intended function, the input type, the default filters, and the explicit error behavior. It does not describe the output schema or parameter behaviors, but the unsupported status makes those less critical, and an output schema is present to cover return values.

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

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

Schema description coverage is only 13%, so the description carries most of the parameter-semantics burden. It explains file, interval, and default exclude flags, but does not clarify bin_size, min_base_quality, min_mapping_quality, or the reference parameter, which are otherwise unexplained by the schema.

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

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

The description states a specific verb and resource: read depth over an interval from indexed BAM/CRAM, and clarifies it is like samtools depth. This is distinct enough from siblings such as get_pileup, get_reads, and get_signal without needing to open the schema.

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

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

It clearly identifies the input domain (indexed BAM/CRAM over an interval) and the default filtering behavior. The explicit 'Not implemented in this build: returns error code unsupported (E4)' tells an agent not to rely on this tool, though it does not name an alternative tool to use instead.

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

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

Annotations already indicate read-only and open-world hints, but the description adds crucial behavioral context: the tool is not implemented and returns error code 'unsupported' (E3, E5). This goes beyond the annotations and informs the agent that any call will fail, which is essential for correct selection.

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

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

The description is two sentences: the first front-loads the core purpose with format constraints, and the second adds the critical caveat that the tool is unimplemented. There is no redundant text; every word contributes essential information.

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

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

For a tool that is not implemented, the description clearly communicates that it will fail, which is the most important fact. An output schema exists, so return details are not needed. However, the description does not explain what E3/E5 mean or suggest alternatives, leaving minor 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 schema description coverage at only 25%, the description needed to explain parameter meanings. It does add some value by specifying that the file must be an indexed BED/GFF3/GTF or bigBed and that results are features overlapping an interval. However, it does not describe max_records or feature_types, so it only partially compensates for the low schema coverage.

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

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

The description states a specific verb-resource combination: returns features overlapping an interval, with explicit file type constraints (indexed BED/GFF3/GTF or bigBed). This clearly distinguishes it from sibling tools such as get_reads, get_variants, and get_coverage. The second sentence also clarifies it is not implemented, which further specifies its current status.

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

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

The description clearly states input requirements (indexed files, specific formats) and explicitly warns that the tool is not implemented in this build, so it should not be used as it will return error code 'unsupported'. However, it does not point to alternative tools for feature retrieval, leaving the agent to infer from sibling names.

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

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

The description discloses a critical behavioral trait: the tool is not implemented in this build and returns error code 'unsupported' (E4). This goes beyond the annotations, which only declare readOnlyHint and openWorldHint. The description also clarifies the input requirement (indexed BAM/CRAM), which is useful behavioral context. No contradiction with annotations.

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

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

The description is two sentences and front-loads the core purpose. The second sentence about the 'unsupported' error is essential and earns its place. No wasted words, though it could have added a bit more parameter context without becoming verbose.

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

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

Given the tool is not implemented, the description is arguably complete for the 'unsupported' path. However, for a tool with 8 parameters and 13% schema coverage, the description does not explain the semantics of the filtering parameters (max_depth, exclude_flags, quality thresholds). The output schema exists, so return values are covered, but the parameter semantics gap makes it incomplete for an agent that might need to construct a valid request.

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 13%, so the description must compensate for the many undocumented parameters. The description mentions 'indexed BAM/CRAM' and 'interval', which maps to the file and interval parameters, but it does not explain max_depth, exclude_flags, min_base_quality, min_mapping_quality, max_records, or reference. The description adds minimal meaning beyond the schema for the core parameters but leaves most parameters 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 verb and resource: 'Per-position base counts over an interval from indexed BAM/CRAM.' This clearly identifies what the tool computes and the input type. It doesn't explicitly differentiate from siblings like get_coverage or get_reads, but the phrase 'per-position base counts' is specific enough to convey the core purpose.

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

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

The description implies usage context: it operates on indexed BAM/CRAM files over an interval. However, it does not explicitly state when to use this tool versus alternatives like get_coverage or get_reads, nor does it mention exclusions. The 'Not implemented in this build' note is a form of usage guidance (don't use it expecting success), but it doesn't help an agent choose between 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?

Discloses the critical trait that the tool is not implemented and returns 'unsupported' (E4), going far beyond what readOnlyHint/openWorldHint annotations convey. Also explains flag filter semantics and the CRAM reference requirement. No contradiction with annotations.

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

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

Three tight sentences, front-loaded with the core function, then flag behavior, CRAM caveat, and implementation status. Every sentence earns its place with 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?

For a tool that returns an error code in this build, the description tells an agent what it would do, its input requirements, key options, and that it cannot be used. Since an output schema exists, return-value documentation is unnecessary. Minor gaps remain around auxiliary parameters, but overall it is sufficiently 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?

With schema description coverage at only 13%, the description compensates partially: it clarifies 'file' is indexed BAM/CRAM, 'interval' is the query locus, 'reference' is needed for CRAM, and flag filters follow samtools -f/-F. However, it does not add meaning for max_records, include_sequence, or min_mapping_quality, leaving those under-specified.

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: 'Alignments overlapping an interval from indexed BAM/CRAM.' This clearly separates it from sibling tools like get_variants or get_signal. The samtools flag filter mention adds further precision about what the tool returns.

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

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

Explicitly warns 'Not implemented in this build: returns error code unsupported (E4)', which is a strong when-not-to-use signal. It also gives a prerequisite for CRAM (matching reference unless self-contained). Does not name alternative tools for the unsupported case, so not a 5.

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

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

The description adds critical behavioral context beyond the readOnlyHint and openWorldHint annotations: it explicitly states that the tool is not implemented in this build and will return error code 'unsupported' (E6, E7). It also clarifies that values are returned exactly as supplied by the source, which is useful non-obvious 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, each carrying essential information. The primary purpose is front-loaded, and the unsupported-status warning is placed second without unnecessary elaboration.

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

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

The description covers purpose and the critical unsupported behavior, and an output schema exists. However, the complete lack of parameter semantics and absence of usage guidance leave meaningful gaps for an agent deciding whether and how to call this tool.

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

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

Schema description coverage is 0%, and the description does not explain what 'source' or 'accession' mean, what formats are expected, or how they relate to the metadata lookup. The description adds no parameter-level meaning beyond the raw schema.

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

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

The description clearly identifies the operation: retrieving one sample's metadata and phenotype values as supplied by the source. It is specific enough to distinguish from list_samples, but it does not explicitly name or differentiate sibling tools.

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

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

No guidance is provided about when to use this tool versus alternatives such as list_samples or describe_dataset. The 'not implemented' warning is behavioral, not usage guidance.

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

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

The description adds the critical behavioral detail that the tool is not implemented and returns an error. This goes beyond the annotations (readOnlyHint, openWorldHint), which do not capture the unsupported status. The description discloses exactly what happens on invocation, which is essential for an agent deciding whether to call it.

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

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

The description is only two sentences, front-loaded with the purpose, and immediately reveals the critical 'not implemented' caveat. There is no wasted text; every word contributes to the agent's understanding.

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 that the tool is not implemented, the description is complete: it states the intended behavior and the actual (error) outcome. The output schema exists, so return format is available elsewhere. The description leaves no ambiguity about whether to call this tool, which is the most important context here.

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

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

Schema description coverage is 0%, so the description must compensate for missing parameter explanations. It only mentions 'indexed FASTA' and 'interval,' which gives minimal context but does not explain the required properties (file, interval) or their nested types. The schema's $defs do provide descriptions, but per the 0% direct coverage signal, the description should have added more parameter detail. It is insufficient.

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: 'Reference sequence for an interval from an indexed FASTA.' This clearly distinguishes it from sibling tools like get_reads or get_coverage, which target different data types. The additional note about being 'not implemented' further clarifies its current state without confusing its intended purpose.

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

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

The description explicitly says 'Not implemented in this build: returns error code unsupported (E3),' which tells the agent not to use it. While it does not name a specific alternative tool, the exclusion is clear and unambiguous, guiding the agent to avoid this tool and try others.

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

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

Beyond the readOnlyHint and openWorldHint annotations, the description adds critical behavioral information: the tool is not implemented and returns a specific error code (E5). This is exactly the kind of context that prevents an agent from wasting time invoking a non-functional 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?

Two sentences, no filler, and the most important operational fact (not implemented) is stated immediately after the purpose. Every word 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?

For a tool that is not implemented, the description provides the essential fact an agent needs: calling it will fail. However, given the complexity of the input schema (nested FileRef and Interval) and the low parameter coverage, the description would be insufficient if the tool were functional.

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 20%, and the description does not explain the parameters (file, interval, bins, summary, max_records). The phrase 'signal values or binned summaries' hints at bins and summary, but it does not compensate for the low schema coverage or clarify how the parameters interact.

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

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

The description clearly identifies the operation: retrieving signal values or binned summaries over an interval from bigWig files. It distinguishes itself from sibling tools by naming the data type (bigWig) and the concept of signal, though it does not explicitly contrast with get_coverage or other genomic retrieval tools.

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

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

The description explicitly warns that the tool is not implemented in this build and will return an 'unsupported' error, which tells the agent not to rely on it. However, it does not suggest an alternative tool or explain when this tool would be preferred if it were implemented.

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

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

The description goes beyond the readOnlyHint annotation by disclosing that the tool is not implemented and will return error code 'unsupported' (E3). This is critical behavioral information an agent needs to avoid relying on the tool.

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

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

The description is two sentences with no wasted words. The primary purpose is front-loaded, and the critical unsupported status is stated immediately after. Every sentence 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?

The description is complete for this tool's context. It explains what the tool does, where the transfer comes from, and that it is unsupported with a specific error code. The presence of an output schema covers return-value details, so nothing essential 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%, so the description must compensate. It adds meaning by indicating that transfer_id refers to a transfer started by fetch_file, which helps the agent understand the parameter's origin. However, it does not explain the format or expected value beyond that, leaving some ambiguity.

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

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

The description clearly states the tool's function: getting progress/result of a transfer started by fetch_file. It names the specific resource (transfer) and the initiating operation (fetch_file), distinguishing it from sibling tools like cancel_transfer and list_files.

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

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

It provides clear context for when to use the tool: after a transfer has been started by fetch_file. It also explicitly warns that the tool is not implemented in this build, which is an important exclusion. It does not name alternative tools, but the unsupported status makes the primary guidance unambiguous.

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

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

Annotations declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds critical behavioral context: it explicitly states the tool is NOT implemented in this build and returns error code 'unsupported' (E4). This is valuable beyond annotations and prevents an agent from expecting real results.

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 sentences, front-loaded with the core function, and the critical 'not implemented' warning is placed second. No wasted words, though the 'not implemented' disclosure could arguably be even more prominent.

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

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

The description is complete about the tool's current non-functional status, which is the most critical context. However, with 6 parameters and only 17% schema coverage, an agent would struggle to construct correct arguments for a tool that isn't even implemented. The output schema exists but the description doesn't clarify what the 'unsupported' error means for invocation.

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

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

Schema description coverage is only 17%, so the description must compensate for undocumented parameters. The description mentions 'variant records and optional genotypes' which maps to include_genotypes, and 'overlapping an interval' maps to interval, but it doesn't explain file, samples, pass_only, or max_records semantics. The schema itself documents only max_records, leaving most parameters 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 verb ('get') and resource ('variant records and optional genotypes overlapping an interval'), and the VCF/BCF format qualifier distinguishes it from other genomic retrieval tools. However, it doesn't explicitly differentiate from siblings like get_reads or get_features beyond the format mention, so it's clear but not fully differentiated.

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

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

The description implies usage for retrieving variant records in an interval, and the format qualifier (VCF/BCF) gives some context. But it doesn't explicitly state when to use this vs alternatives like get_features or lookup_variant, nor does it mention exclusions or prerequisites beyond the 'not implemented' note.

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

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

Annotations declare readOnlyHint=true and openWorldHint=true, so the description does not need to restate those. However, the description adds a critical behavioral note: 'Not implemented in this build: returns error code unsupported (E9)'. This is valuable transparency. But it also mentions a privacy condition about external annotation, which is useful but vague. The description does not explain what constitutes 'external sources' or the exact scope of the unsupported feature.

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 concise, consisting of two sentences. The first sentence states the purpose and the privacy condition. The second sentence reveals the unsupported status. The text is front-loaded with the core function, and the critical limitation is provided early. There is no fluff, so every sentence 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?

The output schema exists, so return value details are not required. However, the description is incomplete for a complex tool with 6 parameters. It fails to mention how parameters like files, interval, max_records interact, or what 'public evidence' means. The unsupported status is a major caveat but is not fully contextualized. The lack of usage guidance and parameter semantics leaves an agent guessing about how to construct a valid request.

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 33%, so the description must compensate for parameters not documented in the schema. The description mentions allow_external_annotation, which adds meaning beyond the schema's boolean field. However, it does not explain the other parameters like files, interval, reference, max_records, or reference_sources. The interval and files parameters likely have clear semantics from their type definitions, but the description does not help an agent understand how to populate them for this tool. Thus, it partially compensates but leaves gaps.

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

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

The description states the verb 'Combine' and the resource 'data from several files at one locus', which gives a clear overall purpose. However, it does not differentiate this tool from siblings like get_reads, get_variants, or get_features, which also return data at a locus. The phrase 'plus public evidence' hints at combining external data, but it's not explicit enough to distinguish it clearly.

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

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

There is no guidance on when to use this tool versus alternatives. The description does not mention any conditions, prerequisites, or alternative tools. An agent would not know whether to prefer inspect_locus over get_reads or get_variants for a given task.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds a critical behavioral fact beyond annotations: the tool is not implemented and returns error code 'unsupported' (E2, E6, E7). This is valuable transparency, though it does not elaborate on pagination or other runtime behavior.

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

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

The description is two sentences with no filler. The primary purpose is front-loaded, and the unsupported-status caveat is placed second. Every word 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?

The description adequately discloses that the tool is non-functional in this build, which is essential context. However, it leaves parameter semantics unexplained and the error codes (E2, E6, E7) undefined. Since an output schema exists, return-value details are less critical, but the overall guidance is still incomplete for a 5-parameter tool.

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

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

Schema description coverage is only 20%, with only max_records having a description. The tool description does not explain source, accession, cursor, or formats, and only vaguely implies that accession refers to a study/dataset. It fails to compensate for the low schema coverage.

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

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

The description states a specific verb and resource ('List files of a study/dataset') and enumerates the returned fields (format, size, checksums, index, readiness), which distinguishes it from sibling tools like list_samples or fetch_file. However, the 'Not implemented in this build' caveat muddies what the tool actually does in practice, so it is not a perfect 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?

There is no guidance on when to use this tool versus alternatives such as fetch_file, list_samples, or describe_dataset. The only usage-related information is that it is unsupported in this build, which tells the agent not to use it but does not explain what to use instead or under what conditions it would be appropriate.

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

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

The description explicitly discloses that the tool is not implemented and will return error code 'unsupported' (E6, E7). This is a critical behavioral trait that the annotations (readOnlyHint, openWorldHint) do not convey. The agent is clearly informed that invoking this tool will fail, which is excellent transparency.

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

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

The description is two short sentences. The purpose is stated first, and the crucial 'not implemented' caveat is front-loaded in the second sentence. Every word earns its place; there is no redundant or extraneous 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 and annotations already cover the safety profileVERT. The description adds the decisive fact that the tool always errors, so an agent can make an informed decision not to call it. The missing parameter meanings are a gap, but because the tool is universally unsupported, they are less critical than they would be for a working tool.

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

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

Schema description coverage is only 25%, with only max_records having a description in the schema. The tool description does not explain source, accession, or cursor semantics, and only vaguely hints that a 'study/dataset' is involved. The description fails to compensate for the schema's lack of parameter documentation, leaving most parameters underspecified.

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

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

The description states a clear verb and resource: 'List samples of a study/dataset'. This distinguishes it from siblings like list_sources and list_files by naming the specific entity (samples). The phrase 'as supplied by the source' adds slight ambiguity about the nature of the list, and the intent is somewhat undercut by the 'Not implemented' caveat, but the core purpose is still evident.

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

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

The description gives no explicit when-to-use or alternative tool guidance. The statement 'Not implemented in this build' is an implicit warning not to use the tool, but it does not point to an alternative for listing samples. Unlike strong definitions that name sibling alternatives, this one leaves the agent to infer whether another tool can serve the same function.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the read-only nature is covered. The description adds that it returns the state and supported operations of sources, which is useful context beyond the annotations. However, it does not disclose any other behaviors like pagination or error conditions.

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 concise sentence with no redundant words. It is appropriately short and front-loaded with the main action.

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

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

The description is minimal. It does not explain the optional 'kind' parameter or any usage context. While the output schema exists, the description leaves gaps in understanding how to call the tool effectively, especially since there is no guidance on when to filter by kind.

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

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

The description does not mention the 'kind' parameter at all. With 0% schema description coverage, the description must explain the parameter's meaning and possible values, but it fails to do so. The agent is left to guess what 'kind' 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?

The description clearly states the verb 'list' and the resource 'data and reference sources', and specifies that it returns their state and supported operations. This distinguishes it from sibling tools like list_files and list_samples, which target different resources.

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

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

No guidance is provided on when to use this tool versus alternatives. It does not mention when to filter by kind or how it relates to other listing tools. This leaves the agent to infer usage.

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

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

The description explicitly discloses the tool's behavioral limitation: 'Not implemented in this build: returns error code 'unsupported' (E8).' This goes beyond the readOnlyHint and openWorldHint annotations, clearly telling the agent the call will fail. This is highly transparent.

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

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

The description is extremely concise—two sentences with no filler. The primary purpose is front-loaded in the first sentence, and the critical caveat follows immediately. Every word 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?

For a tool that is not implemented, the description fully communicates the outcome (error code E8). It does not detail the intended return format, but since the tool cannot be used, the essential context is present. The description adequately covers the current behavior, though it omits details that would be relevant if the tool were functional.

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% (only the 'sources' parameter has a description). The tool description adds no information about the meaning or expected format of 'gene', 'include', or 'assembly'. With low coverage, the description should compensate but does not, leaving these parameters effectively 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 what the tool provides: 'Gene identifiers, transcripts and source-attributed annotations.' This is a clear statement of the resource and scope, though it lacks an explicit verb (e.g., 'retrieve' or 'lookup'). The 'not implemented' notice further clarifies the current purpose is to return an error, which is transparent.

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

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

The description does not mention when to use this tool versus its siblings (e.g., lookup_variant, lookup_protein). It only states it is not implemented and returns an error, which implicitly discourages use but offers no alternative or decision guidance.

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

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

Beyond the readOnly/openWorld annotations, the description explicitly discloses that the tool is not implemented and will return error code 'unsupported' (E8). This is a critical behavioral trait an agent cannot infer from the schema or annotations, and it is stated precisely.

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

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

The description is two sentences, front-loads the purpose, and then adds the essential unsupported warning without wasted words. It is appropriately sized for the tool's stub nature.

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

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

The description adequately covers purpose and the critical unsupported status, and an output schema exists to fill return-value details. However, it leaves gaps around input identifier format and does not route the agent to a working sibling tool, so completeness is adequate but not strong.

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

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

With schema coverage at 50%, the description needed to clarify the required 'protein' parameter, but it only says 'Protein identity...' and does not specify accepted identifier types (e.g., UniProt accession, gene name). The 'sources' parameter is already described in the schema, so the description adds little parameter-level meaning.

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

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

The description states the resource (protein) and data source (UniProt and cross-references), and 'identity, function and features' makes the lookup intent clear. It is distinguishable from sibling lookup_gene and lookup_variant by the protein focus, though it lacks an explicit verb in the description itself.

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

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

The 'Not implemented in this build' warning tells the agent that invoking this tool will produce an unsupported error, which is a meaningful negative usage signal. However, it does not provide positive when-to-use context or name an alternative tool for protein lookups, so the guidance is only partial.

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

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

The description goes well beyond the readOnlyHint and openWorldHint annotations by disclosing that the tool is not implemented and will return error code 'unsupported' (E8). It also clarifies that the output contains no consensus or clinical verdict, which is essential behavioral information an agent could not infer from the schema or annotations.

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

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

The description consists of two tight sentences with no filler. It front-loads the core purpose, then immediately adds the two most important caveats: no consensus/clinical verdict and not implemented. Every clause contributes information.

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

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

The description is adequate for a stub because it clearly tells the agent the call will fail, and the output schema exists to cover return values. However, it does not explain the valid parameter combinations or point to an alternative tool, leaving gaps for a hypothetical implemented version and for agents seeking a replacement.

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 17%, so the description needed to compensate, but it does not explain hgvs, rsid, variant, include, or assembly. The mention of ClinVar, gnomAD, Ensembl, and optional Atlas loosely hints at the sources parameter, but the primary variant-identification parameters remain entirely 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 clearly states the tool provides source-attributed evidence for a variant and names the external sources (ClinVar, gnomAD, Ensembl, optional Atlas). It also explicitly excludes consensus/clinical verdict, which helps distinguish its output scope, though it does not directly compare against sibling tools like get_variants or resolve_identifier.

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 'Not implemented in this build' warning and the 'No consensus or clinical verdict' exclusion give the agent clear signals about when not to use the tool. However, it names no alternatives and offers no explicit guidance for choosing this tool over sibling tools, leaving the positive use case mostly implied.

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

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

Beyond the readOnlyHint and openWorldHint annotations, the description discloses the most important runtime behavior: the feature is a stub that returns 'unsupported' (E8). This gives the agent the critical failure-mode context needed to avoid invoking it. The meaning of 'trace' is left vague, but no contradiction exists.

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, both purposeful: the first states the operation and constraints, the second states the critical unsupported status. There is no filler, repetition, or unnecessary reproduction of schema fields.

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

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

The unsupported notice is the most important contextual fact and is present, so an agent knows not to expect a working result. However, the description leaves parameter selection and the meaning of 'trace' unexplained, and does not point to an alternative tool, so the agent is not fully equipped to route to a working normalization path.

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

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

Schema description coverage is only 17%, so the description must compensate. It usefully maps 'VCF-style, HGVS or rsID' to the variant/hgvs/rsid parameters and emphasizes an explicit assembly, but it does not address the reference or sources parameters, nor the expected mutual exclusivity of the three input modes. This is helpful but incomplete for safe invocation.

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 ('Normalize a variant'), enumerates accepted input forms (VCF-style, HGVS, rsID), and adds a distinctive condition ('explicit assembly', 'with a trace'). This is enough to set it apart from sibling lookup/resolve tools without requiring schema inspection.

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

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

It explicitly says the tool is not implemented in this build and returns error code E8, which is a clear when-not-to-use signal. It does not name a fallback alternative such as lookup_variant or resolve_identifier, so it stops short of full routing guidance.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true. The description adds two important behavioral facts: it reports ambiguity and it returns error code 'unsupported' (E8) in this build. This goes beyond the annotations and is crucial for an agent to avoid wasting a call. No contradiction exists.

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 sentences with no extraneous content. The main purpose is stated first, followed immediately by the critical caveat. Every word 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?

Given the tool is not implemented, the description tells the agent it will fail, which is essential. However, parameter semantics are missing, and no alternative tools are suggested. The output schema exists but its content is not provided here. The description is adequate for a non-functional tool but not 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 only 25% (only 'sources' has a description). The description does not explain any parameters, though it hints at identifier types. It does not clarify 'assembly' or 'target_types' semantics, so it fails to compensate for the low schema coverage.

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

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

The description clearly states a specific action ('Resolve') on a defined resource ('gene/transcript/protein/variant identifier') and mentions the behavioral trait of reporting ambiguity. However, it does not explicitly differentiate from sibling lookup tools such as lookup_gene or lookup_variant, so it is clear but not distinguished.

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

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

No guidance is given on when to use this tool versus alternatives. The only usage-related information is the warning that it is not implemented, but it does not direct the agent to an alternative tool or specify conditions for selection. Thus, there is no effective usage guidance.

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

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

Even though annotations already mark readOnlyHint and openWorldHint, the description discloses that the tool is a stub that always returns an unsupported error (E6, E7). That is precisely the kind of behavior an agent cannot infer from annotations or schema. It fully signals the critical trap of calling 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?

Two sentences: the first states the core purpose in a compact phrase, the second delivers the critical caveat. Every word earns its place and the most decision-relevant fact (unsupported) is prominent. This is appropriately sized for a stub tool.

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

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

For a disabled tool, the description tells agents not to call it and what error to expect, which is sufficient for that purpose. However, it gives no hints about how to accomplish the intended search task otherwise, such as consulting list_sources or another tool. Given the six-parameter schema, a pointer to alternatives would have made it 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?

The description only hints that 'query' is a text query and that 'source' identifies an archive/catalog; the other four parameters (cursor, assembly, organism, max_records) are entirely unexplained. With only 17% schema coverage, this leaves most parameter semantics to inference. The stub status mitigates the impact, but the description adds little to the schema.

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

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

The description names the action ('search'), the resource type ('studies or datasets'), and the input ('text query'), and narrows scope to 'one archive/catalog'. It does not explicitly contrast with sibling lookup tools, but its search intent is distinct. The appended 'not implemented' warning is clear, though it slightly complicates the stated purpose.

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

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

The warning 'Not implemented in this build: returns error code unsupported' makes an explicit when-not to call the tool. However, it offers no alternative tools or conditions for using this search instead of the many sibling lookup/retrieval tools. Thus guidance is present but incomplete.

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