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, indicating no side effects. The description adds that the tool returns the product and junction primers, which is useful but does not elaborate on the return format or any potential limitations. With annotations covering safety, the description provides adequate additional 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 a single sentence that immediately conveys the core functionality, output, and supported methods. It is front-loaded and contains 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 complexity (15 parameters) and lack of output schema, the description provides a basic understanding but does not elaborate on the output format (e.g., what the 'product' is) or how multiple methods compare. It is minimally complete but could benefit from additional 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?

Schema description coverage is 100%, so each parameter is already well-documented in the input schema. The tool description does not add any parameter-specific information beyond what the schema provides. 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 assembles fragments using Gibson/overlap, Golden Gate (Type IIS), or restriction–ligation methods, and returns the product and junction primers. It specifies the verb 'assemble' and the resource 'fragments', and distinguishes the tool from siblings like 'golden_gate_fidelity' by covering multiple assembly methods.

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 provide any guidance on when to use this tool versus alternatives, such as when to choose a specific assembly method or how it compares to other cloning-related tools like 'golden_gate_fidelity' or 'in_silico_pcr'. No exclusion criteria or context for selection is mentioned.

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?

The description adds that it 'picks the most-frequent codon per residue' and accepts DNA/RNA (translated first) via the parameter description. Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is clear. However, limitations (e.g., tie-breaking, rare codons) are not disclosed, and the parameter description bears the burden of explaining DNA translation.

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 18-word sentence that conveys the core functionality without any extraneous information. Every word earns its place.

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

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

For a simple, read-only, idempotent tool with no output schema, the description covers the main purpose, heuristic, and host concept. It does not explicitly state output format but that is inferable. Slightly incomplete regarding edge cases, but overall 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?

The input schema has 2 parameters with 50% description coverage (protein has a detailed schema description, organism just an enum). The main description adds the context of 'expression host' for organism but does not elaborate on parameter details beyond what the schema provides. 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 verb 'codon-optimise' and the resource 'protein (or coding DNA)' for an expression host using a specific heuristic (most-frequent codon per residue). It distinguishes from siblings like reverse_translate or codon_adaptation_index by specifying the optimization strategy.

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 optimizing for an expression host but does not explicitly state when not to use it or mention alternative tools. For example, it doesn't indicate that reverse_translate might be used for a non-optimized back-translation.

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 and idempotentHint, so the description's value is limited. It lists the types of checks performed but doesn't disclose additional behaviors such as performance on long sequences or whether it only analyzes the provided reading frame.

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 effectively communicates the tool's purpose without verbosity. Every word 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?

Given no output schema, the description does not explain what the linter returns (e.g., a report, warnings, or errors). This missing information could hinder an agent from understanding the tool's output format. Additional context about the output 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 coverage is 100% with well-described parameters. The description adds no extra meaning beyond listing the categories of checks. Baseline 3 is appropriate as the schema carries the semantic load.

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

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

The description clearly states the tool lints a coding DNA sequence and lists specific checks (premature stops, RBS/polyA motifs, restriction sites, GC extremes, repeats). It distinguishes from siblings like 'find_orfs' or 'restriction_sites' by being a comprehensive linter.

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?

While the description implies use for quality-checking DNA constructs before cloning, it lacks explicit guidance on when to use this tool versus alternatives like 'construct_autofix' or 'verify_construct'. No when-not-to-use or prerequisites are mentioned.

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, establishing a safe, read-only behavior. The description adds a useful behavioral detail: omitting the 'nuclease' parameter lists available nucleases without scanning. However, it does not disclose other traits like computational cost or output volume, which would be valuable 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 a single sentence of 178 characters, front-loading the purpose without any wasted words. Every part contributes meaning, making it highly efficient. It is concise yet informative.

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 4 parameters, 100% schema coverage, and no output schema, the description fails to mention the structure or format of the returned results. It only says 'find and score', leaving the agent unsure about the output (e.g., list of guides with scores, positions, etc.). This gap is significant for a tool with no output schema.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds some context by linking the 'sequence' parameter to 'target DNA' and 'nuclease' to 'common nucleases', but does not provide extra meaning beyond the schema. For example, 'minScore' and 'searchReverseStrand' are already well-described 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 finds and scores candidate guide RNAs for common nucleases, specifying the verb 'find and score', the resource 'guide RNAs', and the context 'in a target DNA for common nucleases'. It effectively distinguishes from sibling CRISPR tools like crispr_offtarget_check and crispr_hdr_donor.

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 is provided on when to use this tool versus alternatives. The description does not mention exclusions, prerequisites, or which sibling tools to use for related tasks (e.g., off-target checking or donor design). The agent must infer usage from the tool's name and 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 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 declare readOnlyHint=true and idempotentHint=true, establishing safety and idempotency. The description adds transparency by detailing that it checks both strands and is limited to a curated set of genomes, which is beyond what annotations cover.

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

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

The description is two sentences, efficiently conveying purpose and usage guidance. It is front-loaded with the core function and constraints, with no extraneous 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 presence of annotations (readOnly, idempotent) and full schema coverage, the description is sufficiently complete. It covers the critical limitation of genome scope and provides usage comparison, making it comprehensive for selecting and using the tool.

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

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

Schema description coverage is 100%, so the input schema already documents all three parameters. The description does not add significant meaning beyond the schema; it mentions 'protospacer' and 'valid PAM' but does not clarify format or constraints 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 purpose: screening a guide's protospacer for off-target sites against a small curated set of genomes, with explicit distinction from a full genome search. It differentiates from sibling tools like crispr_grna_design and primer_specificity by specifying the limited scope.

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

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

The description explicitly provides usage context: 'Use this the same way primer_specificity is used: a useful sanity check within the covered organisms, not a clearance guarantee for a mammalian expression host.' This clearly indicates when to use and when not to rely on 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 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 indicate readOnly and idempotent. The description adds transparency about the output format (CSV, columns), assumptions (5 uL scale), and limitations (placeholder plate type). 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?

Front-loaded with the core function in the first sentence, followed by necessary assumptions and caveats. Slightly verbose but well-structured. Every sentence adds value; 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 no output schema, the description fully explains the output format (CSV columns) and includes all relevant context: purpose, assumptions, limitations, and needed modifications. Complete for a generation/export 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 descriptions for each field. The description adds meaningful context by explaining the assumed reaction volumes (5 uL scale) and that the user should rescale for their protocol, which informs parameter usage beyond schema definitions.

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?

Clearly states the tool generates a downloadable CSV picklist for Echo liquid handler, specifies exact columns, and distinguishes from sibling tools by mentioning 'at same well positions export_plate_layout assigns'. The verb 'generate' and resource 'Echo picklist CSV' are specific and 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?

Provides guidance on when to use (for PCR reactions) and includes caveats to rescale volumes and replace placeholder plate type. However, it does not explicitly state when not to use or name alternative tools beyond export_plate_layout. The context is present but lacks explicit 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 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 provide readOnlyHint and idempotentHint, and the description adds significant behavioral details: the clustering algorithms (UPGMA, complete, single), distance metrics (euclidean, correlation), row-wise z-scoring, and output structure. This goes beyond what annotations convey.

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

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

The description is a single, dense sentence that efficiently packs the core functionality, algorithmic options, and outputs. 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?

For a tool with 8 parameters and no output schema, the description explains the return structure (leaf order, dendrogram, z-scored values) and algorithmic options. It covers the essential context for an AI agent to 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 description coverage is 100%, so all parameters are already described. The description does not add extra semantic meaning beyond the schema, but the schema descriptions are thorough. 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 verb ('hierarchically cluster'), the resource ('genes x samples expression matrix'), and the specific outputs (leaf order, dendrogram merge trees, z-scored values). It distinguishes itself from sibling tools like 'gene_expression' by focusing on clustering and visualization output.

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 does but does not provide explicit guidance on when to use it versus alternatives, such as when clustering is needed for heatmap visualization vs. other tools. The context of clustering for heatmap is clear, but no when-not or alternative tool is mentioned.

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?

The description adds behavioral context beyond annotations (readOnlyHint, idempotentHint) by detailing IUPAC-awareness, mismatch tolerance, and circular template support. However, it does not disclose output format, potential errors, or performance limitations, which would raise the score to 5.

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

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

The description is a single sentence that conveys all essential information without redundancy. It is front-loaded with the core action and efficiently lists key features in parentheses.

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

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

Given the absence of an output schema, the description should clarify what the tool returns (e.g., product size, sequence, location). Currently it only says 'Predict PCR products', which is vague. Additionally, no prerequisites or error conditions are mentioned. The description is minimally adequate for a simple tool but lacks 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 coverage is 100%, so the baseline is 3. The description does not add parameter-specific details beyond the schema, but it provides overarching context (IUPAC, mismatches, circular) that helps interpret parameter usage. This is adequate but not exceptional.

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 'Predict PCR products' and specifies the key resources 'template and a pair of primers'. It also lists distinctive features like IUPAC-awareness, mismatch allowance, and circular template handling, which differentiate it from sibling tools like primer_design or primer_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 explains what the tool does but provides no guidance on when to use it over alternatives (e.g., primer_design, melting_temperature). No 'when not to use' or explicit trade-offs are mentioned, leaving the agent to infer suitability solely from the purpose.

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, but the description adds valuable behavioral details: the design includes universal tails, deliberate internal secondary mismatch, and reuses the nearest-neighbor Tm engine. 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 purpose, followed by a key behavioral detail. Every sentence contributes 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?

The description thoroughly explains what the tool designs, but since there is no output schema, it omits explicit mention of return values (likely primer sequences). Given the complexity, this is a minor gap.

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

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

Schema coverage is 100%, so baseline is 3. The description enriches understanding by explaining the purpose of tails (FAM/HEX) and the internal mismatch strategy, adding meaning beyond parameter names 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 it designs KASP/ARMS allele-specific genotyping primers for a SNP, specifying the two allele-specific forward primers with tails, internal ARMS secondary mismatch, and a common reverse primer. This is distinct from sibling tools like generic 'primer_design' or 'melting_temperature'.

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: for KASP/ARMS genotyping primer design. It does not explicitly exclude alternatives or provide when-not conditions, but the specialization 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 indicate readOnlyHint=true and idempotentHint=true. Description adds details on calculation methods and outputs (recommendation, molecular weights), providing 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?

Single sentence efficiently conveys purpose, methods, and outputs without 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?

No output schema exists, and the description mentions 'recommendation and molecular weights' but does not specify the full output format. However, for a straightforward calculator, it provides sufficient 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?

Schema description coverage is 100% with detailed parameter descriptions. The tool description does not add significant meaning beyond what the schema already provides.

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

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

Clearly states it calculates primer/oligo melting temperature using nearest-neighbour (SantaLucia 1998), Wallace, and salt-adjusted estimates. Identifies distinct purpose 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?

Implies usage for Tm calculation but does not provide explicit when-to-use vs alternatives or when-not-to-use. No mention of 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?

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?

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=true and idempotentHint=true, so the description's job is to add behavioral context. It adds value by naming the specific algorithms and scoring parameters, which helps the agent understand the computational behavior beyond the annotations.

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

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

The description is a single, well-structured sentence that front-loads the core action and key options. 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?

The tool has no output schema, and the description does not specify what the tool returns (e.g., alignment output format, score). Given the complexity of alignment, some indication of return value is needed for complete 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 is high (83%), but the description enhances understanding by explaining that mode affects algorithm choice (Needleman-Wunsch vs Smith-Waterman) and summarizing the scoring as match/mismatch/gap, which reinforces parameter roles.

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 pairwise alignment of two sequences, specifies the two algorithms (Needleman-Wunsch and Smith-Waterman), and mentions the scoring scheme. It effectively distinguishes from sibling tools like multiple_sequence_alignment by focusing on pairwise comparison.

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

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

The description mentions two modes (global and local) but provides no guidance on when to use each or when to prefer this tool over alternatives like multiple_sequence_alignment. Usage context is implied but not 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 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?

Annotations already provide readOnlyHint, idempotentHint, and openWorldHint, so the description need not restate those. It adds that detection occurs on both strands, which is a useful behavioral detail beyond what annotations convey. 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, front-loaded sentence that communicates the essential purpose without unnecessary words. Every part earns its place.

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

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

The description lacks details about the output format (e.g., list of features, positions, types). Without an output schema, the agent may need to infer the return structure. For a tool with one parameter and moderate complexity, the description is adequate but not fully complete.

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

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

The only parameter 'sequence' is fully described in the schema (100% coverage). The description does not add new meaning beyond 'Nucleotide sequence (raw or FASTA; IUPAC accepted).' Baseline 3 is appropriate as the schema handles the parameter documentation.

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

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

The description explicitly states the tool auto-detects common cloning features (promoters, tags, origins, resistance markers, MCS, primers) on both strands, clearly specifying the verb and resource. It distinguishes from siblings like 'plasmid_deep_annotate' and 'plasmid_full_report' by emphasizing quick detection of common features.

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 quick annotation of common features but does not explicitly state when to use this tool versus alternatives like 'plasmid_deep_annotate'. No exclusions or prerequisites are mentioned, leaving the agent to infer usage context 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 already provide readOnlyHint and idempotentHint, so the description does not need to repeat those. It adds valuable behavioral context: the requirement for an optional sidecar and the specific error behavior if not configured. This goes 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 with no wasted words. The first sentence front-loads the purpose and differentiator, and the second addresses a critical usage requirement. Every sentence earns its place.

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

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

Given the low complexity (2 parameters, no nested objects, no output schema) and the presence of comprehensive annotations, the description is complete. It explains the tool's unique value, required setup, and error handling, leaving no gaps for an agent to interpret.

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

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

Schema description coverage is 100%, so the input schema already fully documents both parameters (sequence, circular). The description does not add additional meaning or constraints beyond what the schema provides, so it meets 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 states it annotates a plasmid against pLannotate's feature library, explicitly distinguishing it from the sibling tool plasmid_annotate by noting the larger signature set. The verb 'annotate' and resource 'plasmid' are specific, and the contrast with the sibling tool provides clear differentiation.

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

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

The description gives clear context for when to use this tool (for deeper annotation with a larger library) and mentions the prerequisite of the pLannotate sidecar. However, it does not explicitly state when not to use it or provide direct alternatives beyond the implied contrast with plasmid_annotate.

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 well beyond the annotations (readOnlyHint, idempotentHint) to detail behavioral traits: it performs a PBS length sweep targeting ~30°C, builds RTT encoding the edit, suggests PE3 nicking sgRNAs 40-90bp away, ranks designs by PAM destruction, and explicitly states off-target activity is not evaluated. 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 well-structured and front-loaded with the main action verb 'Design'. It contains a single paragraph with detailed information, but some phrases could be slightly more concise. Overall, it is efficient and informative without unnecessary 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?

Given the tool's complexity (7 parameters, no output schema), the description thoroughly explains the inputs and outputs (spacer, PBS, RTT, 3' extension, PE3 suggestions). It mentions limiting factors (no off-target evaluation). However, it does not describe the output format or structure, which would enhance 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?

Input schema has 100% description coverage, providing clear parameter definitions for all fields. The description adds context about the overall design process but does not elaborate on individual parameters beyond what the schema already provides. 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 explicitly states it designs SpCas9 prime-editing pegRNAs for substitution, insertion, deletion, or replacement. It details the components built (spacer, PBS, RTT, 3' extension, PE3 nicking-sgRNA), making the tool's purpose very specific and clear. Although a sibling 'prime_editing_twin_design' exists, the description still clearly defines this tool's unique focus.

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 designs but provides no explicit guidance on when to use it versus alternatives like prime_editing_twin_design or base_editing_design. It implies usage for any prime editing but does not mention exclusions or when not to use it. The lack of comparison to sibling tools reduces the score from ideal.

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 off-target activity is not evaluated ('no in-browser reference genome'), which adds value beyond the annotations (readOnlyHint, idempotentHint). It also explains the mechanism (left/right nicks, flap synthesis, annealing) but does not mention computational cost or limits. There is 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 dense paragraph, but every sentence adds necessary technical context. It efficiently explains the complex method without wasted words. Could be slightly improved by breaking into shorter sentences, but overall 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?

The description covers the biological context and when to use the tool. However, with no output schema, it does not describe what the tool returns (e.g., pegRNA sequences, scores, or graphics). For a design tool, mentioning output format would improve completeness. Otherwise, it is fairly complete given the complexity.

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

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

Schema coverage is 100% with detailed parameter descriptions. The description adds value by explaining the role of overlapLength in the mechanism and clarifying that pbsLength is a preference while a full sweep is returned. This goes beyond the schema's static 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 defines the tool's purpose: designing twinPE pegRNA pairs for large replacements. It references the original method (Anzalone et al. 2022) and distinguishes from single pegRNA design, which is a sibling tool. The verb 'design' and specific resource 'twinPE pegRNA pair' make 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?

The description states when to use this tool ('for a replacement too large for a single pegRNA's RTT') and mentions what it does not evaluate (off-target activity). It implies the alternative (single pegRNA design) exists, but does not explicitly say 'use prime_editing_design for smaller edits'. The sibling list includes prime_editing_design, providing 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 description only needs to add behavioral context. It adds that the tool uses a penalty-scoring approach (Primer3-style) and considers structural constraints, which is useful beyond the annotations. 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 of 20 words, efficiently conveying the core function. It is front-loaded with the verb 'design' and key identifying details (Primer3-style, constraints). 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?

Given the complexity (19 parameters, no output schema), the description is too brief. It does not mention the return format (e.g., list of primer pairs with scores), error handling, or parameter interactions. For a tool with many tunable parameters, more context is needed for an agent to use it correctly.

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

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

Schema description coverage is only 47%, meaning many parameters (e.g., gcMax, tmMax, lenOpt) lack descriptions. The description does not explain individual parameters; it only broadly mentions constraints. With low schema coverage, the description fails to compensate by clarifying parameter roles or defaults.

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: de-novo PCR primer design using a Primer3-style penalty picker, enumerating and scoring candidate primer pairs against specific constraints (length, Tm, GC, 3'-clamp, structure). This specific verb-resource combination distinguishes it from siblings like kasp_primer_design (KASP-specific) or in_silico_pcr (simulation).

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 it's for designing new primer pairs, but it does not explicitly state when to use versus alternatives like primer_specificity or melting_temperature. No when-not-to-use or exclusion criteria are provided, leaving the agent to infer 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?

While annotations already indicate readOnlyHint and idempotentHint, the description adds behavior details: it is self-hosted, e-PCR-style, and checks against a specific set of genomes (E. coli K-12). It also explains what the tool does NOT do, which is useful for setting expectations. 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 sentences with no fluff, front-loaded with main purpose. Could be slightly more concise, but the information density is good and 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?

Given the lack of output schema, the description adequately covers what the tool does, its scope, and limitations. It mentions the reference genome list and advises on pairing with in_silico_pcr. No major gaps for the tool's purpose.

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 clear descriptions. The description adds extra nuance: reversePrimer can be batched against a fixed forwardPrimer, and maxProductLength is a search-window cap. This adds meaning beyond the schema's basic 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 performs an e-PCR-style screen for off-target amplicons against curated reference genomes, specifically distinguishing it from checking intended targets (which requires in_silico_pcr). The verb 'screen' and resource 'primer pair against reference genomes' are specific, and the purpose is differentiated from sibling tools like 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?

Explicitly states when to use (for background/host-genome specificity) and when not (not for intended target), and recommends pairing with in_silico_pcr. Also clarifies batching behavior: batchable over reverse primers against a fixed forward, not independent primer-pair batching. Provides clear 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, 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.

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

The description is two sentences, both front-loaded with essential information. Every word adds value, with no redundancy or filler. Efficient and clear.

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 three parameters are well-described in the schema, the description sufficiently covers the workflow. It mentions the asynchronous nature and need to poll, but could optionally specify the format of jobId. Overall adequate for a submission tool with no 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 clear descriptions for each parameter. The description does not add additional parameter-level meaning beyond the schema. It restates the overall function but not per-parameter details. 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 verb (submit), resource (protein sequence to EBI InterProScan), and output (jobId). It distinguishes itself from the sibling tool 'protein_annotate_poll' by indicating that this is the submission step and polling is done separately.

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 the workflow: submit and then poll with protein_annotate_poll. It does not list exclusions or alternatives, but the context makes it clear that this is the submission step. The requirement for a protein sequence is implied but not stated as a prerequisite.

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

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

Annotations already declare read-only and idempotent hints. The description adds meaningful behavioral details: sliding-window approach, use of published scales, and handling of non-AA characters. 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?

Single, efficient sentence that immediately conveys the core functionality. No extraneous 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?

Given the schema and annotations cover the needed details, the description is largely complete. However, the output format ('profile') is vague; mentioning that it returns a list of scores per window position would improve completeness. Still adequate for a low-complexity tool.

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

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

Schema coverage is 100%, so the schema fully documents parameters. The description adds context like 'ProtScale-style' but does not provide additional meaning beyond what is in schema descriptions. 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 specifies the tool computes a sliding-window hydropathy/hydrophobicity profile, referencing ProtScale and published amino-acid scales. It distinctively names the resource (protein sequence) and the operation (profile computation), differentiating it from broader sibling tools like '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?

No explicit guidance on when to use this tool versus alternatives such as 'protein_properties' or 'codon_adaptation_index'. The context is implied by the tool name, but the description does not provide conditions or exclusions to aid 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 (readOnlyHint, idempotentHint) already assure safety and idempotency. The description adds the set of computed properties but no additional behavioral context (e.g., no mention of return format or limitations beyond the schema).

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

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

Single sentence that efficiently lists the key outputs, no superfluous content. Front-loaded with the 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?

Given no output schema, the description adequately specifies the output (computed properties). For a tool with two parameters and a narrow scope, this is sufficient. However, the lack of return format details is a minor gap.

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

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

Schema coverage is 100% with descriptions for both parameters. The tool description does not add new information about parameters beyond the schema, meeting the baseline but not exceeding it.

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