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

Annotations already declare readOnly/idempotent/non-destructive/openWorld, so the safety profile is covered. The description adds genuinely new behavioral context: the node is resolved first and tolerates case, apostrophes, and ids, and it advises reporting absence rather than guessing. No rate limits or performance notes, but the extra detail is meaningful.

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 capability in sentence one, then usage, then return shape. Every sentence carries information, though the parenthetical examples and the 'Also ideal' sentence make it denser than strictly necessary.

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

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

There is no output schema, and the description compensates by spelling out the return shape ({node:{...}, relationships:[{dir, rel, neighbor_label, count}]}) plus node-resolution behavior and the semantics of an empty result. Complete for an agent to call and interpret 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 coverage is 100%, so baseline is 3. The description goes beyond the schema by explaining that the query value is resolved before use and accepts case variants, apostrophes, and ids, which clarifies what a valid `query` actually is.

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 ('Show what a node is ACTUALLY connected to') and enumerates exactly what is returned: relationship types, neighbour label, direction, count. The emphasis on ACTUAL connections implicitly distinguishes it from the schema-level sibling (get_spoke_schema), which returns possible rather than observed edges.

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 two concrete usage contexts: (a) choosing which relationship to traverse, and (b) avoiding thrashing when an expected edge type is absent, including worked examples (PRESENTS_DpS, LOCALIZES_DlA). It names no alternative sibling as the 'use X instead' path and states no explicit when-not, so it stops short of a 5.

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

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

Annotations already declare readOnly/idempotent/non-destructive, and the description still adds substantial behavioral context: endpoint resolution is case/apostrophe/id safe, the search is a bounded bidirectional allShortestPaths that is anchored and 'cannot scan the graph', and it discloses the no-path-within-max_hops outcome plus remediation. This is rich disclosure well 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?

Front-loaded with the core purpose and the query patterns it serves before mechanics. Slightly long with the explanatory clause 'so you can read off the intermediate nodes and mechanism in ONE call', but every sentence contributes useful signal, so it is close to optimal.

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 6-parameter graph-traversal tool with no output schema, the description supplies the return shape ({source, target, max_hops, paths:[{hops, nodes, rels}]}), failure behavior, and performance characteristics. Nothing an agent needs to call it correctly is missing.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaning beyond the schema by explaining that both endpoints are resolved first (input-normalization semantics for source/target) and that exceeding max_hops yields a reported no-path result rather than silence. It adds less for max_paths and the optional label params.

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+scope: 'Find the shortest connecting path(s) between two entities in SPOKE'. It goes further and names the query patterns it answers ('how are X and Y connected / what links X to Y') plus 'subgraph-bridge questions', which cleanly separates it from siblings like query_spoke or describe_node.

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 frames the situations that select this tool (connectivity/path questions, subgraph bridging) and contrasts it with the alternative approach of 'probing many queries'. It does not name a specific sibling as the fallback nor state when NOT to use it, so it falls short of a 5.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false, so the safety profile is covered. The description adds real behavioral context beyond that: it is derived live from the database, robust to new/renamed labels, small, and cached. It stops short of describing exact response size or cache TTL, but the caching and liveness disclosure is a meaningful addition.

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 dense sentences, front-loaded with the return payload, followed by liveness/caching caveat and usage routing. Every sentence earns its place with no 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?

There is no output schema, but the description fully characterizes the return value (node labels with counts, edge directory with counts and cost flags) and the caching/liveness behavior. Combined with complete parameter coverage, an agent has everything needed to call 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 100% and the single 'refresh' parameter is fully documented in the schema itself. The description reinforces this by stating the result is 'small and cached,' but adds no syntax or format detail beyond what the schema already provides, so the 3 baseline 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 ('Return a COMPACT, curated map of the current SPOKE graph') and enumerates exactly what the map contains: node labels with counts and a Source->REL->Target edge directory with counts and cost flags. It is clearly distinguishable from siblings like query_spoke or resolve_entity, which it names as downstream tools.

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

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

Gives explicit when-to-use and when-not-to-reread guidance: 'call it ONCE near the start of a task, then rely on resolve_entity + query_spoke.' It also names a concrete use case ('Use the edge_directory to pick the exact relationship type... before writing Cypher') and implies the exclusion (don't re-call repeatedly; use refresh only if needed).

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

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

The annotations already declare readOnlyHint=true and destructiveHint=false, but the description adds substantial behavioral detail beyond them: writes are rejected, unbounded non-aggregate queries receive an automatic safety LIMIT, a transaction timeout aborts pathological queries, and output is trimmed and capped. This is rich, relevant disclosure for a graph-query tool.

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

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

The description is front-loaded with the core purpose and then organized into behavioral notes and tips. Every part is useful, though the bulleted behavior section is somewhat long relative to the minimal information an agent needs to start using the tool.

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

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

For a complex, open-ended Cypher query tool with no output schema, the description is complete enough: it covers safety constraints, automatic limits, timeout behavior, and output trimming and capping. It also provides the necessary prerequisites involving resolve_entity and get_spoke_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 both parameters are already well documented in the input schema. The description repeats the guidance to pass literals via parameters rather than inline them, which adds little beyond the schema's own examples and warnings, so the baseline of 3 is appropriate.

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

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

The description states a specific verb and resource: execute a read-only Cypher query on SPOKE for biomedical knowledge inference. It also distinguishes the tool from siblings by telling the agent to resolve names first with resolve_entity and use get_spoke_schema for relationship guidance.

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

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

It gives a clear workflow: resolve names first, consult get_spoke_schema for edge types, and pass literals via parameters. It does not explicitly state when not to use this tool or directly compare it against all siblings, so it falls short of a 5.

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

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

Annotations already declare readOnly/idempotent/non-destructive/openWorld, so the safety profile is covered. The description adds genuinely non-obvious behavior: it relies on range and full-text indexes, never scans the whole graph, and handles case-sensitivity, apostrophes, synonyms/brand names, and cross-vocabulary identifiers — all traits an agent cannot infer from 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 purpose, then progressively adds the why, the failure modes it handles, the return shape, and the next step. Dense but every sentence carries weight; only the multi-vocabulary enumeration runs slightly 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?

No output schema exists, yet the description specifies the return shape ({label, name, identifier, matched_on, score}) and the downstream usage pattern. For a 3-parameter, single-required-param tool, an agent has everything needed to call it and act on results.

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

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

Schema coverage is 100%, so a 3 is the baseline, but the description adds real value beyond the schema by enumerating supported identifier vocabularies (DOID, Entrez, Ensembl, DrugBank, UMLS CUI, UBERON, GO) and by specifying how the returned `name`/`identifier` feed into query_spoke.

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 precise verb+resource: map free-text name/synonym/identifier to canonical SPOKE node(s). It clearly distinguishes itself from the sibling query_spoke by being the resolution step that precedes querying, rather than the query itself.

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

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

Explicit sequencing instruction ('Use this BEFORE query_spoke') plus a follow-up instruction on what to do with results (query by returned exact name or identifier via query_spoke's `parameters` argument). It even covers the ambiguous case: when several candidates look plausible, state which was picked and why.

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