workbench

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

Annotations already declare readOnlyHint and idempotentHint. The description adds details about return values (confidence, model version, file URLs) and the failure case ({found:false}), plus the license. No contradictions.

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

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

Two sentences, front-loaded with the core action, no 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?

Given the simple one-parameter input and no output schema, the description fully explains the return format including success and failure cases.

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

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

Schema coverage is 100% with a clear description and example. The tool description does not add further parameter guidance 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 specifies the action ('look up'), the resource ('UniProt accession in the AlphaFold Protein Structure Database'), and the database license. It clearly distinguishes itself from sibling tools like 'protein_annotate' or 'sequence_fetch' by focusing solely on AlphaFold predictions.

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 use when needing AlphaFold predictions for a given UniProt accession. It does not explicitly state when not to use, but the narrow scope makes misapplication unlikely.

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

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

Beyond the annotations (readOnlyHint, idempotentHint), the description adds rich behavioral context: it scans candidate sites, builds the antisense oligo with specific chemistry, screens for liabilities, and explicitly states what it does not do. This fully informs the agent of the tool's 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 long, front-loads the core purpose, and includes all essential details without unnecessary words. Every sentence adds value.

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

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

While the purpose and behavior are well described, the output format is not mentioned. With no output schema to rely on, the agent is left uncertain about what the tool returns (e.g., list of designs, scores). This gap reduces completeness for a read-only design tool.

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

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

The input schema covers all three parameters with descriptions, but the description adds meaningful context by explaining the 5-10-5 architecture linking wing and length, and the screening steps. This provides additional semantics beyond the schema defaults and descriptions.

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 designs ASO gapmers against mRNA targets, specifies the 5-10-5 architecture, and distinguishes itself from sibling tools like siRNA or CRISPR design tools by focusing on antisense oligonucleotides and explicitly mentioning no transcriptome-wide off-target search.

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 for when to use this tool (for ASO gapmer design) and mentions a key limitation (no transcriptome-wide off-target search), implying alternative tools might be needed for that. However, it does not explicitly name alternatives or state when not to use it.

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

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

The description adds behavioral details beyond annotations (readOnlyHint=true): it explains strand handling, reporting of forward-strand changes for reverse guides, and classification of edits. Annotations already indicate safety, so the additional context is valuable. It lacks details on output format or pagination but is sufficient.

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

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

The description is a single paragraph that is front-loaded with the main purpose and contains no fluff. It is slightly long but every sentence adds value. It could be slightly more structured (e.g., bullet points) but remains clear and efficient.

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

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

Given no output schema, the description fully explains what the tool returns: reported editable bases, bystander flags, amino-acid consequences, and ranking of bystander-free guides. It covers strands and editing types completely. No gaps are present.

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

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

With 100% schema coverage, the description still adds significant meaning: explaining what edible bases are, what bystander edits mean, and how frameStart affects amino-acid classification. This goes beyond the schema descriptions, providing critical context for proper parameter usage.

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 designs cytosine (CBE, C→T) or adenine (ABE, A→G) base-editing gRNAs for SpCas9 targets, reports editable bases, flags bystander edits, and classifies amino-acid consequences. It distinguishes itself from sibling tools like crispr_grna_design and prime_editing_design by specifying the base editing context.

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

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

The description implies usage for base editing design and differentiates from siblings by naming specific editors (CBE, ABE). However, it does not explicitly state when not to use this tool or provide alternatives, leaving some inference to the agent.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the description does not need to reiterate safety. It adds context about batch execution and return format but lacks details on error handling or limits. With annotations, this is adequate.

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-loaded with core action, and every sentence adds value. No wasted 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?

Despite no output schema, the description mentions return format ('a table of per-record results'). Combined with annotations and schema, this is complete for an agent to select and invoke the tool correctly.

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

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

Schema coverage is 100%, so baseline is 3. The description adds meaning beyond schema labels by explaining 'input' as multi-FASTA or one per line, 'tool' as any batchable tool name, and 'args' as shared arguments. This helps the agent understand parameter semantics.

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

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

The description clearly states the verb 'run' and the resource 'one SeqBench tool over many records at once'. It distinguishes from sibling tools, which are individual sequence analysis tools, making this a meta-tool for batching.

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 applying a tool to multiple sequences, but does not explicitly state when not to use it or mention alternatives. However, given the context and sibling tools, the purpose is clear enough for an agent to decide.

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 readOnlyHint and idempotentHint. The description adds behavioral context by listing the types of analyses performed (composition, ORFs, enzymes, etc.), which helps the agent understand the scope. No contradictions 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 a single, concise sentence that front-loads the key purpose and lists the outputs efficiently. No unnecessary 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?

Given the tool's complexity (multiple analysis types), the description covers the main outputs. However, it does not mention the output format or any caveats (e.g., optional parameters). Annotations and schema cover safety and parameter details, so overall completeness is good but not perfect.

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

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

Schema description coverage is 100%, so the parameter meanings are well-documented in the schema. The description adds no additional parameter semantics beyond what is in the schema, so baseline score is appropriate.

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

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

The description clearly states that the tool auto-detects sequence type and provides a comprehensive characterization including composition, ORFs, enzymes, primers, protein properties, and a BLAST link. This effectively differentiates it from siblings that focus on specific aspects like find_orfs or protein_properties.

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

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

The description implies the tool is for comprehensive analysis ('One-paste tell me everything'), but does not explicitly state when to use it versus alternatives or when not to use it. Sibling tools provide context, but the description lacks direct 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 idempotentHint=true, so the description's addition of returning product and junction primers adds some context but does not disclose potential edge-case behaviors like enzyme name rejection or method-specific constraints. No contradiction with annotations is present.

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

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

The description is a single, front-loaded sentence that states the core action and output without any filler. It is concise and efficiently communicates the essential purpose.

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

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

The description provides a clear high-level summary and return value, which is helpful given the absence of an output schema. However, for a complex 15-parameter tool with multiple methods, a slightly richer description of what the output looks like (e.g., format of product or primers) would improve completeness. The rich schema and annotations mitigate this gap.

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

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

Schema description coverage is 100% with detailed descriptions for every parameter, including defaults and method-specific usage. The tool description itself does not add parameter semantics, but the schema already carries the full burden, so the baseline score of 3 is appropriate.

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

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

The description clearly states the tool assembles fragments via Gibson/overlap, Golden Gate (Type IIS), or restriction–ligation, and returns the product and junction primers. It uses a specific verb and resource, and the mention of multiple methods distinguishes it from simpler sibling tools like double_digest or in_silico_pcr.

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 use for simulating cloning assemblies but does not explicitly contrast with sibling tools such as golden_gate_fidelity or verify_assembly. It gives no when-not guidance or alternatives, leaving the agent to infer usage from the tool name and description.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the description does not need to restate these. The description adds context about the analysis outputs (CAI, adaptiveness, rare-codon, GC3) but does not disclose any unexpected behaviors, side effects, or limitations beyond what annotations provide.

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

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

The description is a single well-formed sentence that efficiently conveys the tool's purpose without redundancy. Every word contributes to meaning, making it easy to scan and understand quickly.

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

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

The tool has moderate complexity (4 parameters, no output schema), but the description does not explain what the tool returns (e.g., numerical values, plots, or a report). It omits details about output format, error conditions, or required input validation, leaving the agent to infer 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 75%, and the schema itself provides clear descriptions for all parameters (e.g., sequence: 'should start in-frame at ATG'). The description adds no new meaning beyond listing the analysis components, so it meets the baseline but does not enhance parameter understanding.

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

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

The description explicitly states that the tool computes Codon Adaptation Index and per-codon relative adaptiveness for a coding sequence against an expression host, including rare-codon and GC3 analysis. This clearly identifies the tool's specific function and distinguishes it from sibling tools like codon_optimize and gc_content.

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

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

The description provides no guidance on when to use this tool versus alternatives (e.g., codon_optimize for modification, gc_content for simple GC). It does not mention exclusions or prerequisites, such as requiring a valid coding sequence starting with ATG.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true. The description adds the deterministic algorithm ('most-frequent codon per residue'), which reinforces idempotency. It does not mention that coding DNA is translated in frame +1 up to the first stop codon (a key behavior), though that detail is captured in the input schema's protein parameter description. Overall, it adds some useful context beyond annotations.

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

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

The description is a single sentence, front-loaded with the purpose, and contains no superfluous words. It effectively communicates the core function and method in a compact form.

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

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

There is no output schema, and the description does not explicitly state what the tool returns (presumably an optimized DNA sequence). It also omits how the tool handles ambiguous inputs (e.g., protein-only vs DNA) beyond the 'protein' parameter schema. For an agent to know the invocation's result, this is a notable gap, though the tool's simplicity mitigates it.

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

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

Schema description coverage is 67%, with detailed descriptions for 'protein' and 'inputType'. The main description adds the term 'expression host' which maps to the 'organism' parameter, but does not further explain the 'organism' enum or default. The schema itself provides sufficient meaning for all parameters, so the description does not need to compensate much.

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 a specific verb ('Codon-optimise') with a clear resource ('a protein (or coding DNA)') and states the method ('picking the most-frequent codon per residue'). It clearly distinguishes from siblings like 'reverse_translate' (which does not optimize for a host) and 'codon_adaptation_index' (which computes a score, not an optimized sequence).

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 use for host-specific codon optimization ('for an expression host'), but does not explicitly state when to use this tool versus alternatives or when not to use it. Sibling tools like 'reverse_translate' are not mentioned as alternatives, and no exclusions are provided.

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 contradicts the annotation readOnlyHint=true because the tool clearly modifies the sequence (substitutes codons). According to the rule, a score of 1 is given when description contradicts annotations. The description itself is transparent, but the contradiction undermines trust.

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 with four sentences covering purpose, scope, limitations, and context. Every sentence earns its place with no 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?

Given the complexity (10 parameters, no output schema) and the annotations with contradictions, the description covers the main purpose and limitations but lacks details on output format, error cases, and parameter interplay. It is minimally adequate but leaves 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 60%, but the tool description adds no additional information about the 10 parameters. The description does not explain parameter roles, defaults, or interactions beyond what is in the schema, so it fails to add 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 iteratively substitutes synonymous codons to resolve unwanted restriction sites and other issues flagged by construct_qc, without changing the encoded protein. It distinguishes itself from sibling tools like construct_qc and codon_optimize by focusing on fix-ups after QC.

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 advises to re-run construct_qc afterward, implies it should be used after construct_qc detects problems, and states what it does NOT touch (premature stops, GC extremes). This provides clear when-to-use and 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 readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description adds behavior by enumerating the features it flags, which suggests the output will be a report of those issues. It does not contradict the annotations and adds useful context beyond what annotations declare, though it does not specify output format or error handling.

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

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

The description is a single sentence that front-loads the verb 'Lint' and immediately enumerates the checks in a compact list. Every word contributes meaning, and there is zero fluff or redundancy.

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

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

With 8 parameters and no output schema, the description plus the rich schema annotations cover the behavior well. The absence of an explicit return-format description is a minor gap, but the term 'lint' implies a report, and the enumerated checks give a clear picture of what will be flagged. The tool's scope is adequately complete for selection and invocation.

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

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

Schema description coverage is 100%, and every parameter (sequence, gcLow, gcHigh, gcWindow, frameStart, avoidEnzymes, homopolymerMin, crypticOrfMinAa) has a rich description and defaults. The tool description itself does not discuss parameters, but the schema fully carries that burden, so the baseline of 3 is appropriate.

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

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

The description uses a specific verb ('Lint') and a specific resource ('coding DNA sequence'), and enumerates the exact checks it performs: premature stops, internal RBS/polyA motifs, unwanted restriction sites, GC extremes, and repeats. This clearly distinguishes it from siblings like gc_content or restriction_sites, which target only a single check.

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 conveys a clear use case: comprehensive QC of a coding DNA construct. It implies that this tool should be used when multiple sequence features need to be validated at once, but it does not explicitly name alternatives or state when not to use it. Hence it provides clear context without 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 mark the tool as readOnlyHint=true and idempotentHint=true. The description goes well beyond by stating that scores are predicted, not measured; that models are pre-2016 and superseded; that ordering is a ranking aid only; and that scores are null rather than padded for invalid conditions (SaCas9, Cas12a, SpCas9-NG). This fully discloses the tool's limitations and behavior, adding significant 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 front-loaded with the main purpose in the first sentence. Every subsequent sentence adds value (caveats, validity conditions). While it could be slightly more concise by merging some warnings, the trade-off for clarity is acceptable. No superfluous text.

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

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

Despite lacking an output schema, the description explains what the output contains (scored guides), when scores are null, and what the order means. It also handles edge cases (no scan if nuclease omitted). For a tool of this complexity (multiple nucleases, scoring models, validity conditions), the description is remarkably complete without needing to reference external documentation.

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

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

Schema coverage is 100% — all four parameters have descriptions in the JSON schema. The description does not add new parameter-specific details beyond what the schema already provides (e.g., minScore default, nuclease enum, sequence format, searchReverseStrand). According to guidelines, with high schema coverage the baseline is 3, and the description does not improve upon this.

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

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

The description explicitly states the tool finds and scores candidate guide RNAs for specific nucleases, which clearly distinguishes it from siblings like crispr_offtarget_check, prime_editing_design, and others. The verb 'Find and score' paired with 'candidate guide RNAs' makes the action and resource unambiguous, and the listed nuclease names differentiate from related CRISPR tools.

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

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

The description provides strong usage context: it warns that predictions are not measured, models are superseded, and ordering is only a ranking aid. It also specifies validity conditions (only SpCas9 with NGG PAM and sufficient flanking context; null scores otherwise). However, it does not explicitly name alternative tools (e.g., more accurate models) or say when to prefer those, leaving the agent to infer from the caveats.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, establishing safety. The description adds meaningful context: it reuses primer_design engine, auto-designs genotyping primers, and handles PAM disruption. No contradictions with annotations. Additional detail about 'real size-shift or sequencing target' adds 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 a single paragraph of about 4 sentences, front-loaded with the core purpose. Every sentence contributes necessary information without redundancy. It efficiently covers modes, nuclease constraints, and secondary functionality (genotyping primers).

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

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

The description explains inputs and high-level outputs but does not specify the exact return format (e.g., what sequences or primer pairs are returned). Since there is no output schema, this information is needed for the agent to understand how to use the result. Otherwise, it covers the main use cases and parameter interactions.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds value beyond the schema by grouping parameters into two modes (edit window vs guide cut) and explaining edge cases like Cas12a requiring explicit edit window. It also clarifies the purpose of blockPam and frameStart in the context of PAM disruption.

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 builds an HDR donor with homology arms flanking an edit. It specifies two modes: explicit edit window or guide cut site, and mentions it designs genotyping primers. It distinguishes from sibling tools like primer_design by noting it reuses its engine, and covers nuclease-specific constraints (Cas12a needs explicit window). No ambiguity.

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

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

The description provides clear guidance on when to use explicit editStart/editEnd versus guide parameters, especially for Cas12a. It also explains PAM-blocking behavior. However, it does not explicitly compare to other design tools like prime_editing_design or base_editing_design, leaving the decision to the agent's broader context.

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

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

Annotations already provide readOnlyHint, openWorldHint, and idempotentHint. Description adds extensive behavioral detail: CFD scoring only for SpCas9 20nt spacer, Pearson correlation 0.40, single mismatch limitation, null returns for unsupported nucleases, and that DNA/RNA bulges are not searched. No contradictions 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 front-loaded with the core purpose and then adds important caveats. It could be slightly more concise (e.g., the GUIDE-Seq comparison detail is valuable but adds length), but each sentence earns its place for capturing nuanced behavior. No waste.

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

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

Given the tool's complexity (3 parameters, no output schema, nuanced behavioral constraints), the description covers purpose, scope, limitations, scoring validity, and exception cases. Without output schema, describing the ranking output would improve completeness, but the description is already thorough for a read-only computation tool.

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

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

Schema description coverage is 100%, so baseline is 3. Description adds value by explaining the broader context: that maxMismatches seeding uses maxMismatches+1 blocks, and that nuclease determines PAM pattern. However, it doesn't explicitly describe the allowed sequence range for protospacer beyond what schema provides.

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

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

Description clearly states the tool screens a protospacer for off-target sites (protospacer match + valid PAM, both strands) against curated lab reference genomes, not whole genomes. This distinctively positions it from sibling tools like crispr_grna_design or primer_specificity, with explicit scope limitations.

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

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

Explicitly says to use 'the same way primer_specificity is used: a useful sanity check within the covered organisms, not a clearance guarantee.' States what it's NOT (whole genome search, measured data, safe for multiple mismatches + PAM combinations, valid for non-SpCas9 nucleases). Provides clear when-to-use and 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 indicate read-only and idempotent, but description does not explain what the output or behavior is (e.g., returns stability score, temperature). Without output schema, more detail needed.

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?

Single sentence, front-loaded, no 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?

Tool is simple with 2 params fully covered, annotations present. Lacks output description, but sufficient for basic understanding.

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

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

Schema coverage 100% with descriptions 'First oligo (5'→3')' and 'Second oligo (5'→3')'. Description adds no extra meaning beyond schema, but baseline is adequate.

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?

Clear verb 'Screen' and resource 'two oligos' with specific purpose 'most stable heterodimer'. Distinct from sibling tools like 'primer_design' or 'oligo_analysis'.

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

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

No explicit guidance on when to use vs alternatives. Implied by name and context, but missing when not to use or examples.

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 reveals the tool produces multiple computed values (molar mass, amount, concentration, copy number) which are not captured in annotations or schema. It also clarifies the relationship between inputs (mass ± volume, length or sequence). Annotations already indicate read-only and idempotent behavior, so the description adds valuable output context without contradiction.

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

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

The description is a single, front-loaded sentence that conveys the complete purpose and key input-output relationships without unnecessary words. Every part of the sentence adds value, making it highly efficient.

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

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

Despite lacking an output schema, the description enumerates the computed quantities (molar mass, amount, concentration, copy number) and specifies inputs and prerequisites. Combined with full parameter descriptions in the schema and safety annotations, the tool is fully comprehensible for an AI agent.

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

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

The input schema has 100% description coverage, fully documenting each parameter. The description recaps input types but adds no additional semantics beyond what the schema already provides (e.g., defaults, relationships). The phrase 'from mass ± volume and either a length or a sequence' succinctly summarizes inputs but does not enhance parameter understanding.

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 performs nucleic-acid quantity conversions including molar mass, amount, concentration, and copy number. It specifies input requirements (mass, volume, length/sequence) and output types, making the purpose unambiguous and distinct from all listed sibling tools which focus on design, analysis, or sequence manipulation.

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 when molarity/concentration conversions are needed but does not explicitly state when to use or avoid this tool relative to alternatives. No exclusions or comparisons are provided, though the specificity of the function makes the context clear.

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 and idempotentHint as true, indicating safe, idempotent operation. The description adds behavioral context by mentioning 'flag caveats', which warns about potential issues (e.g., incompatibility). 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 a single sentence that captures the full purpose, including both the primary action and a note about caveats. Every word earns its place; no unnecessary information.

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

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

Given the tool's simplicity (no output schema, two string parameters), the description fully conveys what the tool does and what it returns (a recommendation with caveats). No missing information for an agent to invoke it correctly.

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

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

Input schema coverage is 100% with descriptions for both parameters ('First enzyme name' and 'Second enzyme name'). The description does not add additional meaning beyond the schema, so baseline of 3 is appropriate.

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

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

The description uses a specific verb ('Recommend') and resource ('a single NEB buffer') with clear context ('digesting with two enzymes in one tube'). It uniquely identifies the tool among siblings like 'restriction_sites' which deals with site mapping, not buffer selection.

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 implies when to use: when performing a double digest with two enzymes needing a buffer recommendation. No explicit when-not or alternatives are provided, but the narrow scope makes it distinct from siblings, and the context is clear enough for an 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?

Annotations already declare readOnlyHint, openWorldHint, and idempotentHint, so the tool's safety profile is known. The description adds substantial behavioral context: the CSV columns, the plate type placeholder, the well-layout logic (row-major across a 384-well plate), and the assumption of a 5 uL reaction with explicit volume breakdowns. It also discloses that the plate type code is a placeholder, which is a non-obvious caveat. No contradictions 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?

The description is dense but not wasteful. The first sentence captures the core purpose, and subsequent sentences provide important details (column names, volume assumptions, plate placeholder, well ordering). Every sentence adds value, though it is longer than strictly necessary and could be split into a summary plus caveats.

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

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

With no output schema, the description carries the burden of explaining the return value, and it does so thoroughly: it names the CSV columns, describes plate type placeholders, explains the source plate layout, and flags that the volume scale is not universal. It also references how positions relate to export_plate_layout, which gives richer context. The tool's assumptions and limitations are clearly stated.

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

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

The schema covers 100% of the single parameter 'reactions' with nested object descriptions and a max of 96 entries. The description adds meaningful semantics beyond the schema by explaining how distinct template labels are assigned to unique wells and connecting the parameter to the output layout and volume assumptions. This goes beyond a baseline of 3.

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

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

The description begins with 'Generate a downloadable Beckman/Labcyte Echo acoustic-liquid-handler picklist CSV', which clearly states the action (generate), resource (picklist CSV), and target platform (Echo). It distinguishes from siblings like export_plate_layout and export_opentrons_protocol by specifying the exact output format and its association with Echo acoustic dispensing.

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 PCR reactions on an Echo acoustic liquid handler, and it aligns well positions with export_plate_layout. However, it does not explicitly mention when not to use it or name alternatives such as export_opentrons_protocol, so exclusions are absent. The context is strong, but the guidance could be more direct.

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 indicate readOnlyHint and idempotentHint; the description adds context that the output is a downloadable script with placeholder volumes and labware names, needing review. It does not contradict annotations and provides useful 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?

The description is detailed but front-loads the purpose. It is not overly long; each sentence adds value. Could be slightly more concise, but effectively structured.

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

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

Given no output schema, the description adequately explains what the tool generates and its nature (starting point, not certified), referencing related tools. It covers the usage scenario sufficiently.

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

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

Schema coverage is 100%, but the description adds meaning by noting that master-mix volumes are placeholder constants and that the script uses confirmed labware/pipette API names, enhancing understanding beyond 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 specific verb 'Generate' and resource 'downloadable Opentrons Python Protocol API script', clearly stating the tool's function. It distinguishes itself from the sibling 'export_plate_layout' by referencing well positions from that tool.

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

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

The description implies usage for setting up PCR reactions on a 96-well plate and mentions the script is a starting point, but does not explicitly state when to use vs alternatives (e.g., other export tools) or provide 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 and idempotentHint=true, indicating safe, idempotent operation. The description adds behavioral details: row-major well assignment and the fact that the layout is shared with export tools, ensuring agreement. No contradictions 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 long, front-loads the core purpose, and adds necessary context about sibling tools. Every sentence contributes value without redundancy.

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

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

Given the tool has one parameter, no output schema, and good annotations, the description adequately covers what the tool does, its input constraints, and its relationship to sibling tools. It could be improved by mentioning error conditions or further behavior details, but it is largely complete for an agent to select and invoke.

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

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

Schema coverage is 100%, and the schema already describes the 'reactions' array and its properties. The description reiterates the fields (name, forward, reverse, template) but adds no new semantic detail beyond the schema. The row-major ordering pertains to output, not parameter semantics.

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

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

The description clearly states the tool assigns PCR reactions to a 96-well plate in row-major order and returns well-assignment data for a plate diagram. It distinguishes itself from related tools by mentioning that export_opentrons_protocol and export_echo_picklist use the same layout, ensuring consistency.

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 when to use this tool (for plate layout and diagram rendering) versus the sibling export tools (for file creation), but it does not explicitly state exclusion conditions or provide definitive guidance on tool selection. The mention of sibling agreement helps, but could be more direct.

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 and idempotentHint, so the agent knows it is a safe, deterministic operation. The description adds value by specifying the outputs (leaf order, merge trees, z-scored values) and describing the computation, which goes beyond the annotations. It does not mention potential limitations like matrix size or missing data handling.

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

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

The description is one dense but efficient sentence that covers the core function, algorithmic options, and outputs without redundancy. It is front-loaded with the primary action and every clause contributes to understanding the tool.

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

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

Given the tool's complexity (8 params, no output schema), the description provides a solid overview of inputs, processing, and outputs. It names the return artifacts explicitly, which is helpful. It could be more explicit about the exact data structure of merge trees or edge-case behavior, but the core purpose and data flow are clear.

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?

All 8 parameters have detailed descriptions in the schema (100% coverage), including the meaning of linkage, distanceMetric, and zScoreRows. The main description only briefly summarizes options already present in the schema, so it does not add substantial 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 clearly states the tool hierarchically clusters a genes x samples expression matrix and returns specific artifacts (leaf order, dendrogram merge trees, row-z-scored values) for a heatmap visualization. This distinctly differentiates it from sibling tools like gene_expression or volcano_plot_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?

The context is clear: it is a data-preparation step for the 'Clustered Expression Heatmap visualization.' However, it doesn't explicitly mention when to avoid using it or suggest alternative tools, which keeps it from 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?

Annotations already provide readOnlyHint=true and idempotentHint=true, so the tool's safety is clear. The description adds detail on the report contents (e.g., per-base quality, GC content) but does not reveal additional behavioral traits like output format or potential limitations.

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, well-structured sentence that front-loads key information about the tool's purpose and components. No redundant 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?

Despite no output schema, the description does not specify the output format (JSON, text, etc.) or provide details on return structure. For a complex tool generating multiple QC modules, this omission leaves the agent uncertain about what to expect.

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

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

Input schema has 2 parameters with 100% description coverage, so the schema already documents them. The description adds no extra meaning beyond the schema, meeting the baseline of 3.

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

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

The description clearly identifies the tool as a FastQC-style deep QC report for FASTQ files, listing specific modules (per-base quality, GC distribution, etc.) and mention of warn/fail verdicts against FastQC thresholds. This distinguishes it from siblings like fastq_trim or seqfile_stats.

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

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

The description does not explicitly state when to use this tool versus alternatives like seqfile_stats for basic stats or fastq_trim for trimming. Usage context is implied by the tool's purpose, but no explicit when-to-use or when-not-to-use guidance is provided.

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 indicate readOnlyHint=true and idempotentHint=true, and the description adds details about the trimming algorithms (ungapped sliding-suffix adapter match, BWA-style quality trim) and the outcome (drops short reads, returns stats). This adds value beyond annotations.

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

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

The description is a single dense paragraph that efficiently states the purpose, algorithm, and output. It is appropriately sized and front-loaded, though could be slightly more concise.

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

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

Given the tool's moderate complexity and absence of output schema, the description adequately covers purpose, algorithm, and return values (trimmed FASTQ plus stats). It lacks error conditions or input format verification, but schema covers input format.

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

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

Schema coverage is 100%, so baseline is 3. The description mentions the minLength parameter implicitly by saying 'drops reads below a minimum length', but does not add significant meaning beyond what the schema already provides for each parameter.

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

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

The description clearly states it trims FASTQ reads with adapter and quality trimming, specifying the exact algorithm and returning trimmed FASTQ plus statistics. The verb 'trim' and resource 'FASTQ reads' are specific, and it distinguishes from sibling tools like fastq_qc_report which focuses on QC reporting.

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

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

The description implicitly defines usage for trimming FASTQ with adapter and quality trimming, but does not explicitly exclude other use cases or name alternative tools. It provides clear context but lacks 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 and idempotentHint=true. Description adds minimal extra behavior disclosure beyond 'across all six frames'. No contradictions, but limited added 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?

Single sentence, perfectly concise, and front-loaded with the action. No unnecessary 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?

Given 3 well-documented parameters and no output schema, the description sufficiently states the core function. Could mention output format but not essential for basic use.

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

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

Schema description coverage is 100%, so baseline is 3. Description does not add meaning beyond schema; it does not elaborate on parameters like minAaLength or requireStop.

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 specific verb 'Find' and resource 'open reading frames (ATG…stop)' with scope 'across all six frames'. This clearly distinguishes it from sibling tools like translate or motif_finder.

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 ORF detection but lacks explicit guidance on when not to use or alternatives (e.g., translate for simple translation). No exclusions or context provided.

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 and idempotentHint true, so the description does not need to cover safety. It adds value by listing operations (cleaning, conversion, etc.) but does not disclose additional behavioral traits beyond what the schema provides.

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 that front-loads the key operations. It contains no wasted words, but could be slightly more structured for readability.

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 6 parameters, no output schema, and good annotations, the description adequately summarizes the tool's capabilities but does not mention the output format or any edge cases. It is 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?

With 83% schema description coverage, the schema already documents most parameters. The description summarizes the operations (clean, convert, reverse) that map to parameters, but does not add meaning beyond what is in the schema.

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

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

The description clearly states the tool's function: 'Clean, case-fold, DNA↔RNA convert, reverse and line-wrap a sequence.' It specifies the verb (format) and the resource (sequence), and lists distinct operations that differentiate it from siblings like reverse_complement or translate.

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 but does not provide explicit guidance on when to use this tool versus alternatives or when not to use it. No exclusions or comparisons to sibling tools are given.

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

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

Beyond annotations (readOnlyHint, idempotentHint), the description discloses the statistical method, multiple testing correction (Benjamini-Hochberg), reliance on bundled reference data (human only), and the default background convention. No contradictions 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 a single paragraph of three sentences, front-loading the core purpose and method. Every sentence adds essential information without redundancy.

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

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

Given no output schema, the description could specify the output format more explicitly, but it adequately covers the method, data sources, parameter defaults, and limitations. The 100% schema coverage compensates, making the overall description complete enough for its complexity.

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

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

With 100% schema coverage, the description still adds value by explaining the default background meaning (only annotated genes, like g:Profiler) and the default maxTermSize (matching clusterProfiler). This contextualizes parameter behavior beyond their schema descriptions.

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

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

The description explicitly states it performs over-representation analysis for GO terms and Reactome pathways using the hypergeometric test with FDR correction. It clearly identifies the specific input (query gene list vs background) and output (enriched terms), distinguishing it from sibling tools like gene_expression or crispr_grna_design.

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

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

The description provides clear guidance on when to use this tool (for enrichment of GO and Reactome terms) and explicitly notes that KEGG is excluded due to licensing, which helps manage expectations. It does not list alternative tools for KEGG enrichment, but the context is sufficient for an agent to decide.

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 and idempotentHint, so no destructive behavior. The description adds that the tool returns composition metrics, which is useful but minimal. No mention of edge cases or format of output.

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 efficiently communicates the tool's purpose with no unnecessary words. Front-loaded with key 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 simple tool with one parameter and no output schema, the description is adequate but incomplete. It does not specify the output format (e.g., percentages, raw counts), which would help the agent interpret the result.

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

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

The schema has 100% coverage for the single parameter, which is well-described. The tool description adds meaning by specifying what is computed from the sequence, going beyond the input description.

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

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

The description clearly states the tool computes GC content, AT content, and per-base composition for a sequence. It gives specific outputs, distinguishing it from generic sequence tools, though it does not explicitly differentiate from siblings like 'characterize_sequence'.

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

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

No guidance on when to use this tool versus alternatives. No when-to-use or when-not-to-use information is provided, leaving the agent without context for selection.

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

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

Annotations already indicate read-only and idempotent behavior. The description adds critical detail: each source fails independently (null/empty for its section) and failures are listed in 'sourceErrors' rather than aborting the call. This goes well beyond annotation information.

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

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

The description is a single sentence structure broken into two sentences, packing a lot of detail. While it is somewhat long, every part is informative and front-loaded with the core function. Minor redundancy ('fanned out' and 'in one call') 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?

Given no output schema, the description adequately covers the expected result shape: per-source sections with potential null/empty, and a sourceErrors list. It names each source's contributions. However, it does not specify whether the output is flat or nested, which could be clarified further.

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

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

There is only one parameter (gene) with 100% schema coverage in the description. The tool description adds no further parameter-level detail beyond what the schema provides, so a baseline score of 3 is appropriate.

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

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

The description clearly states that this tool generates a multi-source dossier for a gene/drug-target by aggregating from five distinct sources. It lists each source and what it provides (Open Targets, NCBI/UniProt, ChEMBL, ClinicalTrials.gov, Europe PMC). This distinguishes it from siblings like gene_expression or gene_model which focus on single aspects.

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 'in one call' for a comprehensive overview, but does not explicitly specify when to use this tool versus alternatives like web_search or individual source tools. There is no guidance on prerequisites or limitations, though the parameter description restricts to human genes.

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 indicate readOnlyHint=true and idempotentHint=true, so the tool is safe and idempotent. The description adds value by detailing the specific data sources (GTEx v8, Human Protein Atlas) and the types of data returned, providing useful context beyond what annotations alone convey. However, it does not mention rate limits or other constraints.

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 that front-loads the key concept ('tissue-expression fingerprint'). It includes necessary detail without verbosity, though it could be slightly more concise by breaking the list of data types into separate points.

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

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

Given the complexity of returning multiple data types from two databases, the description adequately lists what is included. However, it does not describe the output format or how to interpret the fingerprint, leaving some gaps for an agent without an output schema.

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

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

The sole parameter 'gene' is described in the schema with examples of symbol or Ensembl ID. The tool description does not add additional meaning beyond the schema, as it only repeats the concept of a gene. Schema description coverage is 100%, so baseline 3 is appropriate.

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

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

The description clearly states the tool returns a 'gene's tissue-expression fingerprint' and lists specific data types (per-tissue median TPM, subcellular localization, RNA tissue-specificity, protein class) from GTEx and Human Protein Atlas. This distinctively identifies the resource and operation, differentiating it from sibling tools that cover sequence analysis, CRISPR design, etc.

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 use when needing gene expression data but does not explicitly state when to use this tool versus alternatives or when not to use it. No exclusions or alternative tool names are provided, leaving the agent to infer the context from sibling names 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 convey readOnlyHint=true and idempotentHint=true. The description adds valuable context: the data is fetched live from Ensembl, uses the canonical transcript, and mirrors the HGVS Converter tool's map. No contradictions, and the extra details help the agent understand behavior beyond annotations.

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

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

The description is a single, efficient sentence that conveys the core function and purpose without superfluous words. Every element 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 low complexity and good annotations, the description adequately explains what the tool does and its source. However, without an output schema, it lacks specifics about the returned data structure (e.g., coordinate lists), which could limit an agent's ability to use the output effectively.

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 only parameter 'gene' is fully described in the schema (100% coverage). The tool description adds no additional meaning beyond the schema, so a baseline score of 3 is appropriate.

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

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

The description clearly states it fetches the exon/UTR/CDS structure from Ensembl for a human gene's canonical transcript, with a specific purpose of rendering an exon diagram. It distinguishes from siblings by specifying the source (Ensembl) and transcript selection (canonical), but could more explicitly contrast with similar tools like gene_dossier.

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 lacks explicit guidance on when to use this tool versus alternatives. It mentions a use case (rendering an exon diagram) but does not provide exclusions, prerequisites, or compare with other tools from the sibling list.

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

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

Annotations indicate read-only and idempotent behavior, and the description adds context about the transparent methodology and its limitations (not reproducing NEB's exact values). No contradictions. The description enhances understanding beyond the annotations.

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

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

The description is two sentences long with no filler. The first sentence clearly states the main function and outputs, while the second clarifies limitations. Very efficient.

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

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

Given the complexity (multiple parameters, optional comparisons, no output schema), the description covers the essential workflow, inputs, and what the tool does not provide. It is sufficient for an agent to understand usage without needing the output schema.

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

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

Schema coverage is 100% with each parameter described well. The description does not add new meaning beyond the schema, but provides context for the overall scoring purpose. Baseline 3 is appropriate.

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

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

The description clearly states the tool scores candidate overhang sets against real ligation data, enumerates specific outputs (specificity, weakest link, risky pairs), and distinguishes itself from alternatives like NEB's undisclosed methodology. It is specific and sets clear boundaries.

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 optional comparison with named sets but does not explicitly cover when not to use the tool or offer direct alternatives. However, it does clarify what the tool does not do (reproduce NEB percentages), which helps guide appropriate use.

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

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

Beyond annotations (readOnlyHint, idempotentHint), the description details internal processes (live Ensembl maps, MANE crosswalk, 3'-rule normalization) and refusal reasons, adding significant 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?

Every sentence is informative and earns its place. The description is well-structured with a clear purpose, detailed behavior, and explicit limitations, all without unnecessary verbosity.

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

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

Given the tool's complexity and high parameter documentation, the description covers most aspects. However, it lacks explicit mention of the output structure (e.g., what fields are returned), which would enhance completeness for an output-schema-less tool.

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

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

The sole parameter 'variant' has full schema coverage, but the description adds crucial context: required format with examples, supported accessions and edit types, which goes beyond the schema definition.

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

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

The description clearly states it converts HGVS 'c.' descriptions to genomic coordinates and predicts protein effects. It specifies supported accessions (gene symbol, RefSeq, Ensembl) and edit types, distinguishing it from sibling tools like variant_annotate.

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 states when to use the tool and lists clear refusal cases (circular/mitochondrial genomes, RNA/protein input, uncertain syntax, etc.), providing excellent guidance on when not to use it.

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

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

Annotations already declare readOnlyHint and idempotentHint, indicating safe, idempotent polling. The description adds value by detailing the response format and a key behavioral trait: normalization of mapped ids regardless of target database. No contradictions 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?

Two efficient, front-loaded sentences. The first states purpose, the second details response lifecycle. No unnecessary words. Perfectly concise for the 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?

For a simple polling tool with one parameter and sufficient annotations, the description is complete. It explains the return value structure and a notable behavior (normalization). No output schema exists, but the description adequately covers what is returned.

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 0%, the description must clarify the parameter. It mentions 'job submitted via id_map_submit', implying the jobId comes from that submission. However, it does not specify format or constraints beyond what the schema provides (type string, required). It adds marginal 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 clearly states the tool's purpose: checking a UniProt id-mapping job submitted via id_map_submit. It specifies the behavior (returns status while running, mapped ids and failed ids when finished), and distinguishes it from the submission tool id_map_submit. The verb 'Check' and resource are explicit.

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

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

The description explicitly ties usage to a prior id_map_submit call, providing clear context. It doesn't explicitly state when not to use the tool, but the complementary sibling relationship is evident. This is sufficient guidance for an AI agent.

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

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

Annotations already provide readOnlyHint and idempotentHint. The description adds value by specifying the 1000 ID limit and that it returns a jobId immediately, but does not add significant behavioral context beyond what annotations imply. 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 concise sentences, front-loaded with the core action and examples, and includes the important note about polling. No wasted 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?

For a submission tool, the description is complete: it explains what it does, the limit, the return value (jobId), and how to get results (poll id_map_poll). The schema covers all parameter details, and the sibling tool for polling is referenced.

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

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

Schema description coverage is 100% with very detailed parameter descriptions. The description adds some examples of valid hops but does not significantly enhance parameter understanding beyond the schema. Baseline of 3 is appropriate.

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

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

The description clearly states the tool submits up to 1000 IDs to UniProt's ID mapping service for a single confirmed-safe hop, with concrete examples like Gene_Name -> UniProtKB-Swiss-Prot. It distinguishes itself from the sibling id_map_poll by stating it returns a jobId to poll.

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

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

The description explains when to use the tool: for a single hop mapping. It mentions polling with id_map_poll and implies multi-hop scenarios require chaining, though this is detailed more in the input schema. Explicit exclusions for non-safe hops are in the schema but not in the description.

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 establish readOnly and idempotent behavior. The description adds valuable behavioral context: IUPAC-aware, mismatch tolerance, and circular template handling. These disclose key capabilities beyond the annotations, though no details on output format or edge cases are given.

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 that conveys the core purpose and three additional capabilities without excess words. Every phrase 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 tool has a well-described schema and clear annotations. The description effectively summarizes the function and key features. It does not describe the output format, but the phrase 'Predict PCR products' sufficiently indicates the return value. The addition of usage alternatives would make it more complete, but for a read-only tool this is 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 coverage is 100%, so the schema already documents all parameters. The description's mention of mismatches and circular templates loosely maps to maxMismatches and circular, but it does not add meaningful detail beyond what the schema provides. Baseline 3 applies.

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

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

The description clearly states the tool's function with a specific verb ('Predict PCR products') and resources ('template', 'pair of primers'). It distinguishes from sibling tools like primer_design (which designs primers) and primer_specificity (which checks specificity).

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: when you have a template and primer pair and want to predict amplification products. However, it provides no explicit guidance on when to prefer this over related tools such as melting_temperature or cloning_simulate, nor any exclusions.

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

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

Annotations already provide readOnlyHint and idempotentHint, so the bar is lowered. The description adds valuable behavioral context: the antisense-strand interpretation, mismatch-class differences between the two primers, grading by Kwok et al. 1990 yields, and reuse of the Tm engine—none of which is in annotations.

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

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

The description is a single dense run-on sentence that front-loads nearly all details without structural breaks. It is information-dense and not wasteful, but its lack of paragraphing or bullet-like separation makes it harder to parse quickly.

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

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

For a complex 8-parameter design tool with no output schema, the description covers the core algorithm, key design constraints, and reporting distinction without explaining exact return values. It is substantially complete for an experienced user, though an explicit output description would have been useful.

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

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

Schema coverage is 100%, so baseline is 3. The description enriches parameter understanding by explaining why FAM/HEX tails are assigned per allele, how amplicon range relates to the reverse primer, and how the secondary mismatch interacts with the natural allele mismatch—value beyond the schema's property descriptions.

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 a specific verb ('Design') and resource ('KASP/ARMS allele-specific genotyping primers for a SNP'), and details the two allele-specific forward primers plus common reverse primer. This clearly distinguishes it from generic primer_design or aso_design 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 implies usage for SNP genotyping and KASP/ARMS applications, but it does not explicitly state when to prefer this tool over sibling tools like primer_design or aso_design, nor does it mention exclusions. Context is present but not fully actionable.

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 idempotent behavior. The description adds methodological context (nearest-neighbour, Wallace rule, Schildkraut-Lifson) but does not detail return format, the pass/fail gate for targetTm, or potential limitations like sequence length restrictions beyond the 14 nt recommendation.

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, information-dense sentence that front-loads the core purpose. It includes relevant details without excessive filler, though the listing of multiple thermodynamic methods makes it slightly heavier than necessary.

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 calculation tool with 7 parameters and no output schema, the description explains what it computes and the methodology, but it does not explain the optional targetTm pass/fail gate or what the response contains beyond molecular weights. It also lacks explicit comparison to sibling oligo analysis tools, which would help in a rich tool ecosystem.

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

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

Schema coverage is 100% with parameter descriptions, so the baseline is 3. The description's mention of 'supplied reaction conditions' and 'molecular weights' adds context to parameters like mgMM and oligoNM but does not directly map to parameter syntax or required input 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?

The description opens with 'Primer/oligo melting temperature' clearly stating the tool's function. It further specifies the calculation method (nearest-neighbour SantaLucia 1998) and includes molecular weights, distinguishing it from sibling tools like primer_design or cross_dimer.

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 Tm calculation and offers some guidance by noting the 14 nt length recommendation and the Wallace rule for shorter oligos. However, it does not explicitly state when to use this tool over alternatives or provide exclusions, such as when to choose primer_design or oligo_analysis.

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

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

The description adds behavioral context beyond annotations by specifying overlapping matches, allowance of mismatches, and dual-strand search. Annotations already indicate read-only and idempotent behavior, so the description effectively supplements these with operation details.

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 that front-loads the action and includes key qualifiers. Every word contributes meaning, with no redundancy or filler. Ideal conciseness for quick parsing.

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 lacks output format details (e.g., positions, list of matches) and does not address limits (e.g., sequence length). With no output schema, the description should compensate, but it does not, leaving an AI agent with incomplete invocation context.

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

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

Input schema has 100% description coverage, so the schema already documents all four parameters. The description adds no new semantic information beyond rephrasing the tool's purpose. Baseline score of 3 is appropriate since schema carries the burden.

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 'Find' and the resource 'occurrences of an IUPAC motif', with specific qualifiers like overlapping, either strand, and allowing mismatches. This makes the tool's exact functionality unambiguous and distinguishes it from sibling tools like 'find_orfs' or 'restriction_sites'.

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

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

The description implicitly defines when to use this tool (motif finding in nucleotide sequences) but lacks explicit guidance on when not to use it or which sibling tools are alternatives. An agent could reasonably infer usage, but clearer direction would improve selection confidence.

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 readOnlyHint and idempotentHint, so no destructive behavior. The description adds value by specifying input constraints (up to 25 sequences) and output features (consensus, per-column conservation), which are not in annotations.

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

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

The description is a single, well-structured sentence that front-loads the core purpose and key details. Every word is informative, with no unnecessary content.

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 single-parameter tool with robust annotations and no output schema, the description adequately covers input constraints and output features. Minor omission: no explanation of the alignment algorithm beyond 'center-star', but this is acceptable given tool simplicity.

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

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

Schema coverage is 100% for the single parameter 'input', which already specifies multi-FASTA format and upper limit. The description repeats this, adding no new semantic detail; baseline 3 is appropriate.

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

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

The description clearly states the tool performs multiple sequence alignment using the center-star method on a multi-FASTA input, producing consensus and per-column conservation. This explicitly distinguishes it from the sibling pairwise_alignment tool.

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

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

The description implies usage for aligning multiple sequences, contrasting with pairwise alignment, but does not provide explicit guidance on when to choose this over alternatives or mention any exclusions.

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

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

Annotations declare readOnlyHint=true and idempotentHint=true, so safety is clear. Description adds that it returns base-pair diagrams and warnings, which is useful but does not elaborate on computational cost or limitations.

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?

Single sentence that is front-loaded with key outputs (Tm, ΔG, ΔH, ΔS, screening, diagrams, warnings). No unnecessary 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?

No output schema provided, so description must explain return values. It lists thermodynamics, screening results, and diagrams, which is sufficient but lacks detail on format or structure (e.g., whether it returns a report, JSON, or visualization).

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 covers 100% of parameters with descriptions (e.g., mgMM, naMM, dntpMM, oligoNM, sequence). The description only restates that it uses sequence and cation concentrations, adding no new 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?

Description clearly states the tool performs full oligo analysis including nearest-neighbour thermodynamics (Tm, ΔG, ΔH, ΔS) and secondary structure screening (hairpin, self-dimer) with diagrams and warnings. This distinguishes it from siblings like 'melting_temperature' which only calculates Tm.

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 explicit guidance on when to use this tool versus alternatives (e.g., 'melting_temperature' for just Tm, 'cross_dimer' for heterodimers). The description implies comprehensive analysis but does not state use cases 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?

Goes well beyond annotations (readOnlyHint, idempotentHint) by disclosing that results are predicted, not measured; that ΔG has ~kcal/mol uncertainty; that MFE structure accuracy degrades with length; and that the model ignores concentration and salt. 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?

Description is fairly long but every sentence adds essential information: purpose, output, comparison, limitations, validity range, parameter usage advice. Front-loaded with core purpose. Could be slightly more streamlined, but no fluff.

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

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

Given the complexity of the tool and absence of output schema, the description thoroughly covers what it computes, parameter sets, temperature, comparators, limitations, validity (≤200 nt), and what it cannot do (ignore concentration, salt, cycling). Provides sufficient context for an agent to use and interpret results.

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 already covers all 5 parameters with high-quality descriptions (100% coverage). Description adds contextual value for temperature (should be annealing temperature) and partition (costs second pass, more honest for competing structures). Modest added value beyond schema, justifying a score above baseline 3.

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

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

Description explicitly states it computes minimum-free-energy structure and ΔG for one or two oligos (hairpin/dimer), contrasting with sibling oligo_analysis's fast stack-sum screen. It clearly defines the resource and action, and avoids tautology.

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

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

Provides explicit when-to-use guidance: full loop model for short oligos (≤200 nt), contrasts with oligo_analysis, warns about uncertainty and limitations (not measured, no PCR failure prediction, ignores concentration/salt/cycling), and advises using partition for ensemble free energy when competing structures exist.

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 readOnlyHint and idempotentHint, so the agent knows it is safe and idempotent. The description adds that unmapped symbols are reported in 'unmapped' and never silently dropped, which is valuable beyond the annotations. No contradictions.

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

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

The description is extremely concise with only two sentences, front-loaded with the key verb 'Look up'. Every sentence provides essential information without redundancy.

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

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

Given that there is no output schema and the tool is a lookup, the description hints at the output structure by mentioning the 'unmapped' field. However, it does not fully describe the response format for successful mappings, which could be improved. Still, it is fairly complete for the complexity level.

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

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

Schema coverage is 100%, so parameters are well-documented. The description adds context about the 50-symbol limit and the behavior for unmapped results, which goes beyond the schema. It also explicitly mentions the Ensembl REST endpoint, adding operational context.

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

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

The description clearly states the tool's purpose: looking up orthologous/paralogous genes for up to 50 gene symbols across species via Ensembl's homology-by-symbol endpoint. It uses a specific verb and resource, and distinguishes itself from sibling tools by its focused functionality.

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

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

The description implicitly guides when to use this tool (when needing orthologs/paralogs for gene symbols) and mentions the source endpoint and constraints. No explicit exclusions or alternatives are given, but the context is clear enough for selection.

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

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

Annotations already declare readOnlyHint and idempotentHint, so safety is covered. The description adds valuable behavioral details about the algorithms and, notably, the semiglobal behavior (terminal overhangs free, no smearing of partial reads). It does not describe the return format, but this is not a major gap given the read-only nature.

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, information-dense sentence that front-loads the core purpose and packs in algorithms, scoring, and gap model without wasted words. It is concise yet comprehensive, well-structured for quick scanning.

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

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

For a complex tool with 7 parameters and no output schema, the description covers the key aspects: modes, scoring, and gap penalties. It does not explicitly state the output format, which would be helpful, but the core functionality and behavioral nuances are sufficiently described. Overall, it is complete enough for an agent to understand when and how to use it.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds minimal parameter-specific meaning beyond the schema; it mentions affine gap costs and scoring modes, but the schema already provides detailed descriptions for each parameter. No significant extra value is added.

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

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

The description clearly states the tool's purpose: pairwise alignment of two sequences, with specific algorithm names (Needleman-Wunsch, Smith-Waterman, Gotoh) and scoring details. It distinguishes itself from multiple sequence alignment by focusing on pairwise, and the specificity of algorithms and modes leaves no ambiguity.

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 through the three modes (global, local, semiglobal), each explained in terms of when they are appropriate (e.g., semiglobal for fitting a partial read to a reference). It does not explicitly name alternatives or when not to use, but the context is clear enough to guide selection.

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

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

Annotations already provide readOnlyHint and idempotentHint. The description adds value by specifying that the tool extracts locus, definition, features, and sequence, which is not obvious from annotations alone. However, it does not disclose error handling, input validation requirements, or output format details.

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, well-structured sentence of 12 words. It front-loads the verb and outcome without any redundant or unnecessary information, earning every word.

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 parser with one parameter and no output schema, the description is fairly complete. It explains what the tool does and what data is extracted. Minor gap: it does not describe the return format (e.g., JSON object structure), but overall adequate given the tool's simplicity.

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

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

Schema coverage is 100% and the parameter description already mentions the GenBank flat file format. The tool description reinforces this but does not add new meaning beyond what the schema provides, so a baseline score of 3 is appropriate.

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

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

The description clearly states the action (parse), the specific resource (GenBank flat file), and the output components (locus, definition, features, sequence). It distinguishes itself from sibling tools like 'characterize_sequence' or 'plasmid_annotate' by its unique 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 provides no guidance on when to use this tool versus alternatives, no mention of prerequisites or when not to use it. The agent must infer usage solely from the tool's name and sibling context, which is insufficient.

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

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

The description is consistent with annotations (readOnlyHint, idempotentHint) and adds context about outputs (traces, peaks). However, it does not describe edge cases (corrupt files), return format, or any potential side effects beyond what annotations already convey.

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

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

Single sentence of 12 words, front-loaded with the action, and lists key outputs efficiently. No redundant 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?

Lacks details about the return structure (e.g., JSON format, array types), file size limits, or encoding requirements. For a tool with no output schema, more description of response format would improve completeness.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does not add meaningful information beyond what the schema already provides (fileBase64 is binary ABIF, fileName is optional).

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 specifies the tool's action ('Decode'), the input format ('Sanger ABIF .ab1/.abi chromatogram'), and the outputs ('base calls, per-base quality, the four dye-channel traces and peak locations'). It is a specific verb+resource and distinguishes from siblings like sanger_vs_reference.

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

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

No guidance on when to use this tool versus alternatives (e.g., sanger_vs_reference). Does not mention prerequisites, file size limits, or when not to use it. The description is purely functional.

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

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

The description goes beyond annotations by disclosing specific matching behavior: exact match required for signatures under 20 bp, ~10% mismatch tolerance for longer signatures, and each feature reporting a 'mismatches' count and 'exact' flag. It also mentions both strands are examined. These are valuable behavioral details not present in the readOnlyHint or idempotentHint.

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 (two sentences) and front-loaded with the core purpose. It lists featured feature types and key behavioral constraints without fluff. No redundant words; every sentence adds value.

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

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

For a one-parameter, read-only tool with no output schema, the description covers the main behavior and even hints at the output (mismatches/exact flags). However, it does not describe the overall return structure (e.g., a list of features with locations). Still, it is sufficiently complete for straightforward annotation use.

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 only parameter 'sequence' already has a complete description in the schema ('Nucleotide sequence (raw or FASTA; IUPAC accepted).'). The tool description adds no additional parameter-level detail beyond this. Since schema coverage is 100%, baseline of 3 applies.

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

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

The description clearly states the tool's function: auto-detecting common cloning features (promoters, tags, origins, resistance markers, MCS, primers) on both strands. This is a specific verb+resource combination and the list of feature types distinguishes it from generic sequence analysis 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 on when to use this tool versus alternatives. Sibling tools like plasmid_deep_annotate and plasmid_full_report exist, but the description does not mention them or any context where this tool is preferred. It only states what it does, not when to use it.

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

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

Annotations already declare readOnly and idempotent hints, but the description adds substantial behavioral context: multi-second runtime, shared-service rate limiting (429/503), reporting of partial/low-identity hits with percent identity, reference coverage, and fragment flags. No contradictions with annotations.

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

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

The description is dense but well-structured, starting with the primary action, then comparing to the sibling, then detailing output attributes and usage caveats. It is slightly long due to parentheticals, but each sentence earns its place and front-loads key 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 complex tool with no output schema, the description explains the nature of returned data (graded alignments, per-feature metrics) and covers performance and rate-limit context. It lacks an explicit description of the full return format, but the provided information is sufficient for selection and invocation.

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

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

Schema description coverage is 100%, so baseline is 3. The description does not add parameter-specific details beyond the schema, but the schema already fully explains the sequence and circular parameters. No extra semantic value provided.

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 annotates a plasmid against pLannotate's feature library, using a specific verb and resource. It distinguishes itself from the sibling plasmid_annotate by emphasizing a larger signature set and graded alignments for partial hits.

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 names plasmid_annotate as the alternative for an instant, unmetered first pass, and describes when the deep annotation is appropriate (when judging weak hits, needing more comprehensive library). Also mentions rate limits, giving practical usage context.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the agent knows it's safe and repeatable. The description adds valuable context: that the unexplained region list is a triage signal, not a defect finding, which shapes how the agent should interpret results. No contradictions 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 a single, well-structured paragraph. The first sentence states the purpose, followed by break down of components. Every sentence adds substance without redundancy. No wasted 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?

Given the tool combines three analyses and has no output schema, the description does a good job explaining what each part does and how to interpret the results. It could briefly mention the return format (e.g., JSON structure) but overall provides sufficient context for a complex tool.

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

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

Schema coverage is 100% with all three parameters (topN, circular, sequence) described. The description does not add additional detail about parameter usage or constraints beyond what the schema provides, so baseline score of 3 is appropriate.

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

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

The description clearly states it combines three analyses: common features, backbone identity/chimera, and crossed unexplained regions. It uses a specific verb 'One combined view' and distinguishes from sibling tools like plasmid_annotate and plasmid_identify.

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

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

The description explains what the tool outputs and includes guidance that the unexplained regions are a triage signal, not a defect. However, it does not explicitly state when to use this tool versus calling its component tools separately or alternatives.

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

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

Annotations already declare readOnlyHint=true (safe read) and idempotentHint=true. Description adds behavioral details: it screens against a small curated list, identifies chimeras, and reports per-match %identity/%coverage. No contradictions 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?

Description is approximately four lines, front-loaded with the primary purpose. Every sentence adds necessary information—what it does, what it excludes, and output details. No filler or repetition.

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

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

Despite no output schema, the description covers the tool's scope (curated set), its outputs (matched vs. unmatched, chimera detection, %identity/%coverage), and its limitations (not a large catalog search). This is complete for a moderate-complexity tool like plasmid identification.

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

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

Schema coverage is 100%—all three parameters have descriptions. The description does not add significant parameter-level details beyond the schema, but it provides context about the reference set ('small curated set of common backbones — see referencesChecked'), which adds some value. Baseline 3 is appropriate.

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

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

Description clearly states the tool screens a query plasmid against a curated set of common backbones, identifies resemblance, separates unmatched region from possible chimera, and reports %identity/%coverage. It distinguishes itself from larger catalog searches, making the purpose precise.

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

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

Explicitly says 'NOT a search against Addgene's ~100k-plasmid catalog or PlasmidScope's 850k+ — a curated-set screen only,' providing clear when-to-use and when-not-to-use guidance. Also explains chimera detection, helping the agent decide when this tool is 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 goes far beyond the readOnlyHint and idempotentHint annotations. It discloses the coordinate frame behavior (1-based inclusive, pre-edit frame), explains the exception for PE3b guides via a coordinateFrame field, and notes the ranking priority for PAM-destroying edits. It also discloses the absence of off-target evaluation, providing deep 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?

The description is long but dense, with each sentence adding value. It is well-structured, starting with the core purpose and then detailing coordinates, ranking, and limitations. While not as curt as a two-sentence example, the complexity justifies the length, and the text is front-loaded with the most important information.

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

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

Despite lacking an output schema, the description explains the shape of the returned data (nickingGuides entries with coordinateFrame) and the key behavioral rules (PAM destruction ranking, coordinate frame semantics). It also notes a limitation (no off-target scoring), making it highly complete for an agent to understand what to expect.

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

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

The input schema already covers 100% of parameters, so the baseline is 3. The description adds some context (e.g., explaining that a pure insertion uses editEnd = editStart - 1), but this duplicates schema descriptions. It does not add significant new meaning beyond the schema for individual 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 opens with a specific verb ('Design') and a precise resource ('SpCas9 prime-editing pegRNAs'), and enumerates the edit types (substitution, insertion, deletion, or small replacement). It clearly distinguishes itself from the sibling tool prime_editing_twin_design by detailing the pegRNA design workflow and PE3 nicking-sgRNA suggestions.

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 scopes when to use the tool: for prime editing of small edits with an NGG PAM, and it states what is and is not evaluated (e.g., 'Off-target activity is not evaluated'). It does not explicitly name alternatives or when-not-to-use, but the scope and constraints are clear enough to guide selection.

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

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

The annotations already mark the tool as readOnlyHint=true and idempotentHint=true, but the description adds extensive behavioral context: it enumerates PBS/RTT combinations, returns multiple scores and design details, explains the Spearman correlation and its limitations, validates against human PE2/PE3 libraries, and clarifies that the number is a ranking not an absolute percentage. This goes well beyond what annotations provide.

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

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

The description is front-loaded with the core purpose in the first sentence, then progressively adds input format, output details, usage guidance, validation statistics, and limitations. Every sentence earns its place—there is no redundancy or filler. Despite its length, it is efficiently organized and essential for correct tool usage.

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

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

For a complex tool with 4 parameters and no output schema, the description comprehensively covers input format (bracketed edit with flanking context), output fields (scores, percentiles, ranks, spacer, PBS/RTT, pegRNA, oligos), ranking behavior, model limitations (cell types, host, editor architecture), and a validation metric. An AI agent has all necessary context to invoke and interpret results.

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?

All four parameters have schema descriptions (100% coverage), and the narrative description adds substantial extra meaning. For 'sequence', it details the bracket format with examples for insertions and deletions. For 'cellType', it explains the absence of a generic option. For 'topN', it mentions enumeration size. For 'use5Folds', it describes the trade-off in compute and stability. This goes well beyond the schema's descriptions.

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 predicts per-pegRNA prime-editing efficiency and returns top-scoring designs. It uses a specific verb ('Predict'), identifies the resource ('PRIDICT2.0'), and describes the input format. While it implicitly differentiates from sibling tools like prime_editing_design by focusing on efficiency scoring rather than design, it does not explicitly name or contrast them, preventing a top score.

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

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

The description provides clear context for when to use the tool ('to CHOOSE between designs') and when not to (non-human hosts, editors outside PE2/PE3 architecture, other cell types). It warns that the output is a ranking, not a promised percentage, and notes limitations on absolute efficiency. However, it does not directly compare to sibling tools like prime_editing_design or prime_editing_twin_design, which would make the guidance more 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 mark readOnlyHint=true and idempotentHint=true, and the description adds rich behavioral detail consistent with those hints: detailed coordinate conventions ('1-based inclusive'), the fact that the PAM search runs on the unedited sequence, the dual-flap annealing mechanism, and the explicit limitation 'Off-target activity is not evaluated.' This goes well beyond the structured annotations and helps the agent set expectations for outputs and algorithm behavior.

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

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

The description is dense but each sentence carries load-bearing information: biological mechanism, coordinate rules, and limitations. It is front-loaded with the primary purpose, then explains the mechanism and constraints. Some sentences are long and technical, which is acceptable given the complexity of a dual pegRNA design tool, but the density reduces readability slightly.

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

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

For a complex tool with six parameters and no output schema, the description covers the necessary context: when to use it, what the algorithm does mechanically, how coordinates are defined, what returned fields mean, and what limitations exist (no off-target scoring). It also accounts for edge cases like pure insertions via replaceEnd = replaceStart - 1, which the schema mentions but the description reinforces the intended context.

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

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

The input schema already documents all six parameters with 100% coverage, so the baseline is 3. The description adds meaningful coordinate semantics (protospacerStart/protospacerEnd/nickPosition are 1-based inclusive in the PRE-EDIT target frame) and clarifies that replaceSpan refers to the 'span of the new content in the returned editedSequence,' which assists in interpreting replaceStart/replaceEnd and newSequence. This supplements—rather than merely repeats—the schema's per-parameter descriptions.

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

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

The description opens with 'Design a twinPE pegRNA pair' — a specific verb plus resource — and immediately distinguishes it from single pegRNA design by noting it's for a replacement 'too large for a single pegRNA's RTT.' It also contrasts the mechanism with 'without an HDR donor,' which differentiates it from similar CRISPR design siblings like crispr_hdr_donor or prime_editing_design.

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?

Clear use condition is stated: use when a replacement is too large for a single pegRNA's RTT. The description does not explicitly name sibling alternatives or state 'do not use if X', but the context is sufficient to infer this tool is the twinPE-specific counterpart to prime_editing_design. The absence of off-target evaluation also provides a boundary on expected behavior.

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

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

Annotations already declare readOnlyHint and idempotentHint, so the description does not need to repeat safety traits. It adds behavioral context by explaining that the tool 'enumerate and score candidate primer pairs against length/Tm/GC/3'-clamp/structure constraints', revealing its algorithmic nature and output type. This goes beyond the annotations without contradicting them.

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

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

The description is a single, information-dense sentence that front-loads the core purpose and method. It includes a parenthetical clarification ('Primer3-style penalty picker') and lists key constraints, all without unnecessary 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?

Given the tool has 19 parameters and no output schema, the description gives a useful high-level overview but omits important details like the return structure (e.g., a list of scored primer pairs) and the role of optional parameters such as targetStart/targetEnd. It is adequate for understanding the core function but falls short of being complete for such a complex tool.

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

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

Schema description coverage is only 47% (9 of 19 parameters have descriptions). The description mentions constraint categories like 'length/Tm/GC/3'-clamp/structure' but does not explain specific parameters such as gcMax, tmOpt, ampliconMin, or targetStart. With this low schema coverage, the description should compensate, but it remains at a high level and adds little value for understanding individual parameters.

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

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

The description clearly states the tool's function: 'De-novo PCR primer design' and specifies the method as a 'Primer3-style penalty picker' that enumerates and scores candidate primer pairs against constraints. This distinctly separates it from sibling tools like melting_temperature (which only calculates Tm) or kasp_primer_design (which is specifically for KASP genotyping).

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 'De-novo PCR primer design' implies the tool is for designing new primers, as opposed to checking existing ones or calculating Tm only. However, it does not explicitly state when to use this tool over alternatives like primer_specificity or aso_design, nor does it provide exclusions or conditions.

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

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

The description goes far beyond the readOnly/idempotent annotations by disclosing coordinate conventions ('1-based inclusive on the plus strand'), circular-genome wrap behavior ('sets wraps: true'), and an important limitation ('nuclear human and mouse genomes are NOT covered'). It also clarifies that the tool does not verify intended-target amplification, a critical behavioral distinction. No contradictions with annotations 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?

The description is one dense paragraph covering purpose, limitations, coordinate system, batch mode, and alternatives. Every sentence contributes useful information, but the density of clauses makes it harder to parse quickly. It could be restructured with bullets, but overall it is appropriately sized for 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?

Given the tool has no output schema, the description compensates by mentioning response fields (genomesChecked, wraps) and providing critical context about genome coverage and coordinate semantics. Combined with the thorough schema descriptions, the agent has all necessary information to select and invoke the tool correctly. The distinction from in_silico_pcr and batch-mode caveats make 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?

Schema coverage is 100% with detailed per-parameter descriptions, so the baseline is 3. The tool description adds contextual meaning about parameter roles: 'Batchable over candidate REVERSE primers against one fixed forward primer' implies forwardPrimer is fixed and reversePrimer is the screening variable. This is extra semantic value beyond the schema's simple '5'→3'' descriptions, justifying a 4.

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

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

The description clearly states the tool's purpose: 'Self-hosted e-PCR-style screen for off-target amplicons predicted by a primer pair against a small set of curated reference genomes.' It names the specific genome set and explicitly contrasts with in_silico_pcr ('pair it with in_silico_pcr against your own template for that'), distinguishing from sibling tools. The verb 'screen' plus the specific resource (primer pair vs reference genomes) makes the purpose unambiguous.

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

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

Usage guidance is explicit: 'This checks background/host-genome specificity, NOT whether the primers hit your intended target — pair it with in_silico_pcr against your own template for that.' It also specifies batch behavior: 'Batchable over candidate REVERSE primers against one fixed forward primer... not independent primer-pair batching.' These statements clearly explain when to use this tool and when to use an 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?

Annotations already declare readOnlyHint=true and idempotentHint=true, indicating a safe, side-effect-free operation. The description adds minimal behavioral context beyond stating it's an in-silico simulation. It does not mention constraints like the maxPeptides cap or the handling of non-AA characters, which are in the schema but not in the description.

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 that conveys the essential information without any verbose or redundant phrasing. Every word contributes to understanding the tool's core function and output.

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

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

Given the lack of an output schema, the description only partially describes the return values (position, length, neutral mass). It does not specify whether the output is a list, the ordering, or how missed cleavages or other parameters affect results. A more complete description would clarify the output structure.

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

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

The input schema has 100% coverage with parameter descriptions, so the description does not need to repeat them. However, the description adds no extra meaning beyond the schema, such as usage tips or parameter relationships. It meets the baseline for a well-documented schema.

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

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

The description clearly states the tool's action ('cleave a protein') and the output ('report each peptide's position, length and neutral mass'). It uses specific verb+resource and distinguishes from sibling tools like 'protein_properties' or 'characterize_sequence' which have broader or different purposes.

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 in-silico digestion but provides no explicit guidance on when to use this tool vs. alternatives, nor does it mention prerequisites or exclusions. The context is clear but lacks direct when-to-use and when-not-to-use instructions.

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

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

Annotations already indicate readOnlyHint and idempotentHint. The description adds valuable behavioral detail about the polling state machine (returns different data when running vs finished) and the specific data returned upon completion.

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, efficiently covering purpose, behavior, and return value. No unnecessary 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?

Given the simplicity (1 param, no output schema), the description fully explains the tool's behavior and return values. No 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 coverage is 0% (no description for jobId). The description implies that jobId comes from a previous submit call, but doesn't provide format or constraints. However, with only one parameter, its purpose is largely self-explanatory.

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 polls an InterProScan job and specifies the return structure for both running and finished states. It distinguishes itself from the submit sibling (protein_annotate_submit).

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 mentions it checks a job submitted via protein_annotate_submit, providing clear usage context. No explicit when-not-to-use or alternatives, but the polling nature makes it straightforward.

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 that the job is asynchronous and takes minutes, which goes beyond annotations (readOnlyHint, idempotentHint). No contradiction with annotations. The description adds behavioral context about immediate return of jobId and need for polling.

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