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

With no annotations, the description carries the full behavioral burden. It discloses one useful constraint (only queued/waiting jobs are cancellable) but says nothing about permissions required, whether cancellation is reversible, what happens to a running job, or how errors surface for an invalid state.

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

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

A single front-loaded sentence stating the action and its constraint, with no filler. Nothing needs to 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?

An output schema exists, so return values need not be explained, and the tool is trivially simple with one required parameter. Still, as an unannotated mutation tool it should at minimum state the consequence of cancelling and the failure mode for non-queued jobs.

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

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

The single parameter job_id has 0% schema description coverage, so the description is the only place semantics could be added, yet job_id is never mentioned. No format, provenance (e.g., obtain via get_job/list_jobs), or validity rules are given.

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

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

States a specific verb+resource ('Cancel a job') plus a scope qualifier (queued or waiting for a GPU), which clearly separates it from siblings like get_job, list_jobs and gpu_status. It does not name a sibling explicitly, but the action is 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 phrase 'still queued or waiting for a GPU' gives an implicit applicability condition, so the agent can infer this is for not-yet-running jobs. However, there is no guidance on what happens if the job is already running, no idempotency note, and no alternatives suggested.

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?

No annotations are supplied, so the description carries the full disclosure burden. It never states that this is a non-destructive read, that it takes no job/session state, or whether it fails for unknown tool names. It partially compensates by listing what is returned, but the output schema already covers that.

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

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

A single tight sentence that front-loads the returned content with zero filler. It errs only in being too sparse rather than too long.

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

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

An output schema exists, so return values need not be re-explained, and the tool is a simple single-parameter read. Still, the meaning of the required 'name' argument and the when-to-use context are left entirely unaddressed, leaving the definition minimally viable.

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

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

The single parameter is 'name' with 0% schema description coverage and no enum. The description does not clarify whether this is a tool name, job name, or resource name, nor the expected format or error behavior for unknown names. It fails to compensate for the coverage gap.

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

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

The description names a specific action (describe/extract metadata) and enumerates exactly what is returned: full input schema, version, and resource needs of a BioHarbor tool. That is far more informative than the name alone. It doesn't, however, distinguish itself from sibling tools explicitly, so it stops short of a 5.

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

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

There is no statement of when to call this versus alternatives, nor any precondition such as 'call before invoking a tool to learn its arguments.' The use case (introspecting a tool before use) is only inferable from the name.

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

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

No annotations provided, so description carries full burden. It does disclose a side effect—writing all ORFs to a FASTA file—and mentions returned coordinates. However, it omits whether the file write overwrites existing files, required permissions, runtime characteristics, or whether the operation is otherwise read-only. Partial behavioral coverage.

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 purpose. The second sentence efficiently covers return format and side effect. No redundant or filler text.

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

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

Output schema exists, so return values need not be explained, though the description does so anyway. Missing usage guidelines and partial behavioral disclosure (e.g., file overwrite behavior) leave the definition incomplete for a tool with no annotations.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters. The description adds little beyond the schema—'both strands' and 'longest ORFs' map directly to parameters but without extra syntax or format details. 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?

States a specific verb and resource: 'Find open reading frames (ATG to stop) on both strands.' Clear what the tool does, but does not explicitly distinguish from siblings like translate_sequence or seq_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?

No when-to-use guidance, no alternatives named, no prerequisites mentioned. The description only implies usage through the purpose statement.

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?

With no annotations, the description carries the full disclosure burden. It usefully reveals the dual return behavior (status while running, result once finished), but says nothing about polling expectations, blocking semantics (wait_seconds is only explained in the schema), authentication, or what a failure/error state looks like.

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

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

A single tight sentence with the primary purpose (status) front-loaded before the conditional result case. Nothing is wasted, though the extreme brevity leaves room that could have been spent on usage guidance.

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

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

An output schema exists, so return values need not be described, and both parameters are documented in the schema. What is missing is the calling context: how this fits with the slow tools that produce job ids and with list_jobs/cancel_job as alternatives.

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 job_id and wait_seconds are already fully documented in the schema, including the blocking cap of 25 seconds. The description adds no parameter-level meaning beyond that, making the baseline 3 correct.

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

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

States a specific resource (background job) and what it returns (status, and result once finished). The 'get' verb plus 'job' clearly separates it from list_jobs and cancel_job by naming convention alone, though the description itself never explicitly contrasts the siblings.

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

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

No statement of when to call this versus list_jobs (to enumerate jobs) or cancel_job (to abort one). The only usage hint is carried by the schema ('Job id returned by a slow tool'), not by the description, so the agent must infer the polling workflow.

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?

No annotations are provided, so the description carries the burden. It usefully discloses that output includes other users' processes, implying cluster-wide visibility rather than just the caller's jobs, which is genuinely valuable behavioral context. However, it says nothing about permissions, refresh/caching behavior, or whether output is a snapshot.

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

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

A single front-loaded sentence with zero waste. The most important qualifier ('live') and the scope note (other users' processes) are both packed into one line.

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

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

An output schema exists, so return-value detail is not required here, and there are no parameters. The description is nearly complete for a zero-arg read tool; the only minor gap is the absence of any usage framing relative to the job-submission siblings.

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

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

The tool takes zero parameters, so there is no parameter semantics to document; baseline 4 applies. The description correctly adds no parameter discussion, consistent with an empty 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?

States a specific resource (GPU memory and utilisation) with a clear scope qualifier ('live'), which an agent can distinguish from the sibling tools (seq_stats, list_jobs, etc.). It doesn't need to name a sibling because none of the others are GPU-related, but it also doesn't explicitly say it is read-only status retrieval.

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

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

No when-to-use guidance is provided. The agent must infer that this is used to check GPU availability before submitting jobs (e.g., before predict_structure or search_homologs). There is no mention of alternatives, prerequisites, or timing.

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?

No annotations are provided, so the description must carry the full behavioral burden. It states what the list contains (installed vs addable) but does not disclose that this is a read-only operation, nor any authentication, side-effect, or rate-limit 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 a single concise phrase with no redundant content, and the key distinction (installed for search_homologs) is front-loaded. It is a fragment rather than a complete sentence, but it wastes no words.

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

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

For a zero-parameter list tool with an output schema, the description covers what is listed. However, it omits when to invoke it and does not state its read-only nature; with no annotations, more behavioral context would be useful, though the output schema handles return 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 tool has zero parameters and the schema description coverage is 100%, so the baseline is 4. The description adds no parameter information because there are none to describe.

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

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

The description names the resource (sequence databases) and distinguishes two subsets: installed for search_homologs and addable ones. While it lacks an explicit verb like 'lists', the tool name supplies that, and the mention of the sibling search_homologs helps an agent understand the scope.

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

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

No explicit when-to-use or when-not-to-use guidance is provided. The reference to search_homologs implies these databases are meant for that tool, giving an implied usage context, but the description does not state that you should call this before search_homologs or how it differs from other siblings.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses that results are omitted from the payload and that ordering is newest-first, but says nothing about read-only safety, pagination, or how 'recent' is bounded.

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

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

A single tight sentence with the ordering and the key caveat front-loaded and zero filler.

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

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

An output schema exists, so return values need no explanation, and the description still helpfully notes results are omitted. The remaining gap is the undocumented limit parameter, a minor omission for such a simple listing 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 only 50%: status is documented in the schema, but limit has no description anywhere. The description adds no meaning for either parameter, so it fails to compensate for the coverage gap.

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

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

States the resource (recent jobs) and the ordering contract (newest first), and explicitly distinguishes itself from get_job, which is a named sibling. It is not a full verb+resource sentence, but the scope is 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?

Routes the agent explicitly: for details of a specific job, use get_job. That covers the main decision point, though it does not say when listing is preferable to other approaches or mention that no filtering beyond status is available.

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?

With no annotations, the description carries the full burden and does a good job: it discloses asynchronous execution ('background job', 'may return a job_id to poll with get_job'), the computed confidence outputs, and the side effect of writing PDB files to disk with pLDDT in the B-factor column. It stops short of GPU contention/time expectations, but the operational profile is well covered.

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

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

Three short sentences, each earning its place: capability first, return artifacts second, execution model third. Front-loaded with the core action and free of filler.

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

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

Even though an output schema exists, the description usefully complements it with output artifacts and async semantics, and it covers the GPU/background-job behavior an agent needs to call correctly. Only minor gaps (expected runtime, GPU capacity limits, failure behavior) remain.

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 both 'sequence' (raw or FASTA, ≤20 records) and 'num_recycles' (more helps hard targets) documented in the schema itself. The description adds no parameter-level detail beyond that, so the baseline 3 applies.

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

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

States a specific verb and resource ('Predict 3D protein structure') plus the concrete method ('with ESMFold on a GPU'), which cleanly separates it from siblings like search_homologs, translate_sequence, or seq_stats. An agent can identify the tool without opening the schema.

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

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

The description implies usage ('predict 3D protein structure') and adds operational routing ('Runs as a background job; may return a job_id to poll with get_job'), but never states when to prefer this tool over alternatives such as search_homologs for structural inference by homology. Usage is implied rather than explicit.

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

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

With no annotations, the description carries the full burden. It usefully discloses that the read is partial ('the start of') and restricted to text output files, but it does not explain the max_bytes limit, truncation behavior, permission requirements, or error cases.

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

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

The definition is a single, front-loaded sentence with no redundant or vague filler. It communicates the core operation and its partial-read nature immediately.

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

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

An output schema exists, so return values need not be explained. However, with no annotations and incomplete parameter documentation, the description leaves gaps around max_bytes semantics and exact usage context that an agent would need when invoking 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 only 50%: path is documented in the schema, but max_bytes is not. The description's '(the start of)' hints at byte limits but does not explain max_bytes or add any path semantics 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?

The description states a specific verb (read) and resource (text output file produced by a BioHarbor tool), and clarifies that only the start of the file is read. It distinguishes the tool from the computation-oriented siblings, which do not read output files. It stops short of a 5 because it does not name or contrast any alternative file-reading path.

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

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

The phrase 'produced by a BioHarbor tool' implies the tool is used on files returned in tool results, but there is no explicit when-to-use guidance, prerequisites, or alternative tools. Usage is therefore only implied rather than stated.

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

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

With no annotations, the description carries the full burden and does well: it discloses the search source (local DB, default Swiss-Prot), the inline return shape (best hits with identity, E-value, coverage, organism, description), the side effect of writing a full hit table to a TSV file, and the async job semantics with polling via get_job. It omits any note on permissions, resource cost, or runtime expectations for a sensitive search.

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?

Four short, front-loaded lines: purpose first, then return shape, then async behavior. No filler, and the job_id/get_job caveat is placed where an agent will see it before deciding to call.

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

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

An output schema exists, so return values need not be re-explained, yet the description still usefully notes the TSV side output and the job_id polling path. It is essentially complete for invocation; only multi-sequence batching semantics and resource expectations are left unaddressed.

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

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

Schema description coverage is 100%, so all seven parameters are already documented (top_n, evalue, max_hits, database, sequence, sensitivity, min_coverage). The description adds only loose framing ('best hits per query', the returned fields) rather than explaining interactions such as top_n vs max_hits or how sensitivity/min_coverage affect results. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

States a specific verb+resource ('Find homologous proteins') plus the underlying engine (MMseqs2) and database scope (Swiss-Prot, PDB, ...). This plainly distinguishes it from siblings like seq_stats, translate_sequence, and find_orfs, which do not perform homology searches.

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

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

Gives clear context: it searches a *local* database, defaults to Swiss-Prot, and runs as a background job that may return a job_id to poll with get_job. The get_job routing is exactly the alternative-selection guidance an agent needs. It doesn't state when-not to use it or explicitly point at list_databases for valid DB names in the description body.

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?

With no annotations, the description carries the full burden. It discloses the output content and cost profile ('cheap first step'), which is useful, but says nothing about read-only semantics, behavior on invalid input, or whether multiple FASTA records are handled. Adequate but incomplete for a no-annotation tool.

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

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

Two short sentences, front-loaded with the metric list. Slight redundancy between the first line and the restatement of what is reported keeps it from a 5.

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

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

An output schema exists, so return values need not be spelled out, and the description still summarizes them. For a single-parameter read-only analysis tool, the coverage is essentially complete aside from invalid-input 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?

Only one parameter with 100% schema description coverage, which already explains it accepts a raw sequence or multi-record FASTA text. The description adds no format or constraint detail beyond the schema, so the baseline 3 applies.

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

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

States a specific verb (validate) and resource (sequences) plus the metrics computed (type, length, GC%, MW), so an agent can tell it apart from translate_sequence or find_orfs. It does not, however, explicitly contrast itself with those siblings.

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

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

The closing line 'a cheap first step before heavier tools' gives clear context on when to reach for this tool rather than the heavier siblings. No explicit exclusions or named alternatives are provided.

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

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

With no annotations, the description carries the full behavioral burden and does add real context: the standard genetic code is used and stop codons render as '*'. However, it omits what happens with ambiguous bases, non-multiple-of-3 input, or invalid characters, which matters for a sequence-translation tool.

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

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

Two short sentences, front-loaded with the core operation followed by the key output convention. Every sentence carries information and there is no filler.

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

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

An output schema exists, so return formatting need not be explained, and the description covers the translation semantics and stop-codon convention. The only gap is behavior on multi-record FASTA input and malformed sequences, which is minor given the complete 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 schema already documents frame (including negative/reverse-complement and 'all'), to_stop, and the FASTA-capable sequence input. The description only loosely echoes the frame behavior ('one frame or all six'), adding little beyond the schema, so the baseline 3 applies.

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

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

States a specific verb and resource ('Translate DNA/RNA to protein') plus the scope of frames, so an agent knows exactly what the tool produces. It does not distinguish itself from the sibling find_orfs, which also translates nucleotide sequence, so the sibling-differentiation credit is missing.

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

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

The phrase 'in one frame or all six' implies when a given frame mode is appropriate, but there is no explicit guidance on when to use this tool rather than find_orfs (which surfaces ORFs) or seq_stats. Usage is inferable rather than stated.

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