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

The description adds performance details (cold search vs cached) and result ordering beyond what annotations provide, with 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 dense but every sentence serves a purpose, front-loading the main action and then detailing requirements, behavior, and alternatives.

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 parameters, output schema presence, and sibling tools, the description covers all necessary context: use cases, prerequisites, behavior, performance, and relationships.

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 value by explaining constraint logic (e.g., name_contains matches per word), providing examples, and listing required anchors.

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 searches UniProtKB with structured filters, lists the return fields, and distinguishes from sibling tools like search_example_queries, run_sparql_query, and get_protein.

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 prerequisites (at least one anchor), provides detailed alternatives for different use cases (broad text or known accession), and explains ordering and caching behavior.

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

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

Annotations already declare readOnly, idempotent, non-destructive. Description adds significant behavioral details: concurrent lookups, return structure (by_gene with matched_gene, resolved_genes, unresolved_genes), and that unresolved symbols are disclosed, never silently dropped. No contradiction with annotations.

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

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

Description is concisely structured: front-loaded with purpose and concurrency benefit, then usage example, return details, optional scoping, and sibling differentiation. Every sentence earns its place with no fluff.

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

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

Given 4 parameters, rich annotations, and an output schema, the description is fully complete. It covers purpose, usage, behavioral details, parameter context, return structure, and next steps. No gaps identified.

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 substantial meaning beyond it: explains concurrency benefit, clarifies return structure, and provides a signature line. Parameter descriptions in schema are clear, but description contextualizes them (e.g., limit_per_gene default and max).

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 resolves several gene symbols to UniProtKB entries in one call, using strong verb-resource 'Resolve SEVERAL gene symbols to UniProtKB entries' and explicitly distinguishes from sibling 'find_proteins' by noting batch vs single gene usage.

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

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

The description gives explicit usage guidelines: use for multi-gene tasks (e.g., 'get domains for PNKP and NAA10'), states that for a single gene use find_proteins, and provides next_commands direction (fan out to get_protein).

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, destructiveHint=false, idempotentHint=true, and openWorldHint=true, so the safety profile is clear. The description adds value by specifying exactly what the tool fetches (SPARQL text, description, keywords, federated endpoints) and revealing that `_meta.next_commands` offers a follow-up action to run the query. No contradictory 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 two sentences long with no redundancy. The first sentence states the purpose and return fields; the second sentence provides usage instructions and a hint about next steps. 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 low complexity (one parameter), rich annotations covering safety, and the presence of an output schema (so return format need not be described), the description is complete. It covers what the tool returns, how to get the ID, and a natural next step via _meta.next_commands.

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, but the description adds the critical guidance that the example_id should be a full IRI from search_example_queries, which is not in the schema description. This helps the agent understand how to obtain a valid 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 uses a specific verb 'Fetch' and identifies the resource as 'one curated example's full SPARQL text, description, keyword tags, and any federated endpoints.' It also distinguishes from the sibling tool 'search_example_queries' by stating that an example_id must come 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 instructs to pass an example_id from search_example_queries and mentions that `_meta.next_commands` offers an alternative to run it via run_sparql_query. This provides clear context for when to use the tool and a hint about an alternative, though it does not explicitly 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 goes beyond annotations by explaining behavior for obsolete/demerged accessions (obsolete flag and replaced_by field) and detailing the response_mode parameter's effect on verbosity and included dates. 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, dense sentence that efficiently conveys all necessary information. It could be slightly more structured, but it remains concise and front-loaded.

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 (two parameters, output schema, rich annotations), the description is highly complete. It covers edge cases (obsolete accessions), response modes, and flags for guiding next steps.

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?

Although the schema has 100% coverage, the description adds context by providing an example accession, explaining the response_mode enum values (minimal, compact, standard, full) and their impact on output.

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

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

The description clearly states that the tool returns the core summary for a single UniProtKB entry by accession, listing specific fields. It distinguishes from sibling tools that focus on specific aspects (e.g., get_protein_sequence, get_protein_variants).

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

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

The description implies usage for retrieving core summary data and mentions flags that drive next commands, but it does not explicitly state when to use this tool versus alternatives or 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?

Beyond annotations (readOnly, idempotent), description adds grouping by database, case-sensitive filtering, unmatched databases echoed with did-you-mean, and response mode effects. No contradiction with annotations.

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

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

Three sentences plus signature, no waste. Purpose front-loaded. 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?

With output schema present, description completes the picture: explains all parameters, behavior, and sibling differentiation. 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 100%, baseline 3. Description adds meaning: explains response_mode returns short ids vs full IRIs, and databases parameter case-sensitivity with typo handling. Accession example given. Adds value 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?

Clearly states 'Return database cross-references for an entry, grouped by database', specifying verb and resource. Distinguishes from sibling 'map_identifiers' by directing focused mapping elsewhere.

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 context on optional restriction to specific databases with case-sensitivity and typo handling. Contrasts with map_identifiers for focused mapping. Could be more explicit about when not to use, but sufficient.

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, non-destructive, idempotent behavior; description adds value by detailing output fields and pairing suggestion, 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?

Two sentences, front-loaded with purpose, efficient and 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?

With output schema present, description explains return fields adequately; single parameter and clear purpose make it complete.

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

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

Schema coverage is 100% with parameter description already including example; description does not add new semantics 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 returns disease annotations with specific fields listed (name, UniProt id, etc.) and distinguishes from sibling tool get_protein_variants.

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 pairs with get_protein_variants for variant-level evidence, providing clear context, though no explicit when-not-to-use is 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?

Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true, and openWorldHint=true. The description adds behavioral details: features use FALDO coordinates, secondary-structure features are hidden by default and disclosed under excluded_secondary_structure, and filter behavior for zero matches. No 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 front-loaded with the core purpose, then efficiently explains filtering and default behaviors. Every sentence adds value; no redundancy or fluff. It is concise yet comprehensive.

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 an output schema (not shown but noted in context), the description covers all necessary aspects: coordinate system, feature types, filtering, secondary structure handling, and the signature. It is complete for a tool of this 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%, but the description adds meaning: for feature_types, it explains that each returned type round-trips to the filter vocabulary and describes the zero-match filter behavior. For include_secondary_structure, it clarifies that secondary structure is hidden by default. The signature line also provides a quick overview.

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 sequence features with coordinates, listing many specific feature types (domains, regions, PTMs, etc.). It uses strong verbs ('Return') and names the resource ('features for an entry'), distinguishing it from sibling tools like get_protein_sequence or get_protein.

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 tells how to use the tool: filter by feature_types, set include_secondary_structure, and notes that secondary structure is hidden by default. It provides context for filtering behavior ('zero-match filter echoes accepted keys'). However, it does not explicitly contrast with alternative tools for retrieving protein data, though siblings are listed separately.

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

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

Annotations already indicate readOnlyHint=true, destructiveHint=false, idempotentHint=true, openWorldHint=true. The description adds that it 'always returns `count` and `count_by_aspect`' and details evidence fields, enhancing transparency 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?

A single sentence packed with essential information, front-loaded with the main action, followed by structured details and a signature. 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 3 parameters, existence of an output schema, and no nested objects, the description fully covers behavior, return structure, and parameter usage. It is complete for an AI agent to use 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 value by explaining the 'token economy' for limit, grouping by aspect, and providing a signature example, elevating it to 4.

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

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

The description explicitly states 'Return Gene Ontology annotations for an entry, grouped by aspect...' with specific output fields (GO id, label, evidence ids). This clearly distinguishes it from sibling tools like get_protein or get_protein_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 advises to 'pass `aspect` to scope to one ontology and `limit` to cap a large set (token economy),' providing clear usage guidance. It does not explicitly exclude scenarios but gives contextual advice.

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?

Description adds valuable context beyond annotations: explains that compact mode returns a preview to limit payload, details the effect of canonical_only, and confirms read-only behavior. No contradiction with annotations (readOnlyHint, idempotentHint).

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

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

Single paragraph with clear, information-dense sentences. Front-loaded with main purpose. Could benefit from minor structural improvements like bullet points but is sufficiently 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 annotations, output schema, and schema coverage, the description adequately covers input behavior, response_mode variations, and canonical_only. No missing elements for effective 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 covers all 3 parameters (100% coverage), and description enriches with examples (e.g., P05067-2 for isoform) and usage tips (e.g., 'cheap for large proteins' for compact mode). Exceeds baseline 3.

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

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

Clearly states it returns amino-acid sequences for an entry, specifying canonical and additional isoforms. Distinguishes from sibling tools like get_protein, get_protein_features, etc., which focus on other 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?

Provides explicit guidance on when to use canonical vs. isoform accessions and how response_mode affects output (e.g., compact mode for large proteins). Lacks explicit comparison to alternative tools but context is strong.

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, destructiveHint=false, idempotentHint=true. The description adds behavioral context by listing return fields and providing an example notation format. No contradictions; adds detail 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 concise (two sentences plus signature), front-loaded with purpose, and every sentence adds value. No unnecessary words or repetition. Efficiently communicates 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 tool has 3 parameters, full schema coverage, and an output schema, the description is complete enough. It explains return fields, filter usage, and signature. Could mention pagination or rate limits, but not essential. Overall very good coverage.

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 good descriptions. The description adds a signature line showing function call format and explains the effect of disease_associated_only. Also provides an example of the notation field. Adds value 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 clearly states the tool returns 'natural-variant annotations for an entry' and lists specific fields (position, wild-type residue, substitution, notation, variant_type, description, diseases, dbsnp). This distinguishes it from sibling tools like get_protein_features or get_protein_diseases by focusing on variants.

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 a specific usage example: 'Set disease_associated_only=true to keep only disease-linked variants.' It does not explicitly contrast with sibling tools, but the context and parameter description imply when to use the filter. Lacks explicit 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, idempotentHint, and openWorldHint. The description adds valuable context about what is returned at each detail level, including the list of tools, accepted argument aliases, response modes, etc. It does not contradict 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 well-structured, front-loading the purpose, then detailing parameter options, and ending with usage guidance. Every sentence adds value, 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?

For a simple one-parameter tool with 100% schema coverage and an output schema, the description is complete. It covers what the tool returns, when to use it, and how it relates to other resources (uniprot://tools, uniprot://capabilities).

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, 'detail', is fully described in the schema and enhanced in the description: it explains the default, the two options, and what each option includes (summary is light with tool list; full adds heavy reference blocks). This adds significant meaning beyond the enum values.

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 the uniprot-link discovery surface, with explicit details about summary vs full modes. It distinguishes itself from sibling tools which deal with proteins and queries, making it clear this is a meta-information 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?

Provides explicit guidance: 'Call this first in a cold session' and suggests alternatives like uniprot://tools or uniprot://capabilities. This helps the agent decide when and how to use this tool.

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, idempotent, and open-world. The description adds: exact match quality tagging ('exact'), ranked name matches, lineage inclusion only for id lookups, and performance characteristics. 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?

Approximately 120 words, well-structured with clear sections: purpose, usage guidance, performance notes, and signature. Every sentence adds unique 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?

For a 2-parameter tool with output schema, the description covers behavioral aspects (output details for each input type), performance, and integration with sibling tools. No gaps remain; completeness is high.

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 description adds context: taxon parameter can be numeric id or name with example, and include_lineage only works for id lookups. This enriches 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 clearly states the tool resolves organisms in UniProt taxonomy, distinguishing it from sibling tools like find_proteins. It specifies two modes: numeric NCBI taxon id for full detail (scientific/common name, rank, parent, optional lineage) and name for candidate ids, with an example (9606). This is specific and actionable.

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 guides when to use: 'Use the resolved taxon id with find_proteins(organism_taxon=...).' It also warns about performance differences: numeric-id and common names are fast (~0 ms), uncommon names trigger a multi-second scan. This helps the agent decide based on input type.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true. The description adds behavior details: response mode controls verbosity, return structure (grouped by database, matched databases, counts), and explains difference between compact and full modes. Adds useful context beyond annotations.

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

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

The description is well-structured with front-loaded main purpose, then details, then alternative tool. It is informative but slightly verbose. Could be more concise, but 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 complexity of mapping to multiple databases, the description fully explains return format (grouped by database, counts, matched databases) and response mode behavior. Output schema exists, so return values are documented. Complete for an agent to use 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 value by providing examples (P05067, isoforms), default database list, and explanation of response_mode values. This exceeds what the schema alone 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 clearly states the tool maps a UniProtKB accession to primary external identifiers, listing specific databases and distinguishing it from the sibling tool get_protein_cross_references. The verb 'map' and resource identification are 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 states default behavior, optional restriction to databases, and directs to get_protein_cross_references for exhaustive cross-references. 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, destructiveHint, idempotentHint, and openWorldHint, covering safety and idempotency. The description adds valuable behavioral details beyond these: auto-injection of LIMIT into unbounded SELECTs with a _meta/truncated flag, federation endpoints, and performance characteristics. 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 reasonably concise given the complexity of the tool. It front-loads the main purpose, then layers details about results, behavioral traits, usage guidance, performance, and signature. Every sentence adds value, though the density could be slightly improved with more structured formatting. 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's complexity (SPARQL endpoint, multiple query types, federation) and the existence of an output schema, the description covers all essential aspects: query types, result formats, auto-limit, escape hatch role, prefix usage, performance tiers, and parameter signature. It does not need to repeat output schema details. The description is comprehensive for effective agent 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 coverage is 100% with detailed parameter descriptions. The description adds additional context: it explains the auto-limit injection and the _meta/truncated indicator, and provides a signature line showing parameter names. This enriches understanding beyond what the schema alone offers, justifying a score above 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 the tool executes arbitrary SPARQL 1.1 queries against the UniProt endpoint, lists supported query forms (SELECT/ASK/CONSTRUCT/DESCRIBE), and explicitly distinguishes it from sibling tools by labeling it as 'the escape hatch for anything the typed tools do not cover.' This provides a precise verb+resource description with 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 provides explicit guidance: it positions the tool as an escape hatch, directs users to seed queries from search_example_queries, mentions using uniprot://prefixes for standard prefixes, and even gives performance expectations (unbounded/federated queries 10-60s, bound lookups <2s). This effectively tells the agent when and how to use the tool versus 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, destructiveHint, idempotentHint, openWorldHint. Description adds search behavior details (free-text over descriptions and tags, return fields) 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?

Concise single paragraph, front-loaded with purpose, ends with function signature. 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 output schema exists and 2 simple params, the description fully covers searchable fields, return types, and workflow. Complete.

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

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

Schema coverage is 100%. Description adds context to text parameter ('free-text filter over descriptions and keywords') and shows signature with defaults, providing marginal extra 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 it searches UniProt's curated SPARQL example queries by free text over descriptions and keyword tags, lists return fields, and differentiates from siblings like get_example_query.

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

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

Provides context for learning how to query UniProt and outlines workflow (fetch full query with get_example_query then run via run_sparql_query). Lacks explicit when-not-to-use but adequate.

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