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

No annotations are provided, so the description carries the full burden. It discloses content categories (Models, Controllers, Jobs) but says nothing about read-only safety, output size/format, caching, or truncation behavior for what is likely a potentially large overview response.

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 no filler, and the parenthetical examples add signal rather than noise. Appropriately sized for a simple zero-arg tool, though it could have added a phrase of routing guidance at little cost.

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 tool with no output schema, the description covers purpose and rough return content. It is largely complete for correct invocation, though a note on the scale/format of the overview would fully close the gap.

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

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

Zero parameters, so there is nothing to document and the schema is trivially complete. Baseline of 4 applies; nothing in the description is needed or missing on the parameter front.

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

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

Clear verb (Get) plus a specific resource (high-level architectural overview), with concrete content examples (Models, Controllers, Jobs) that let an agent predict the output. It does not explicitly distinguish itself from siblings like axon_pro_context or axon_pro_query, but the 'architecture/overview' framing is reasonably distinct.

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

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

The description states what the tool returns but gives no when-to-use guidance, no exclusions, and no routing relative to the many siblings (axon_pro_context, axon_pro_query, axon_pro_related_files). An agent must infer that this is the orientation/first-look 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?

No annotations are provided, so the description carries the full behavioral burden. 'Scan' and 'potential' weakly imply a read-only, non-mutating analysis, but the description never confirms side effects, cost, rate limits, or what the result set 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?

One sentence, front-loaded with the verb and the target problem class, with no filler. 'or heavy database usage' broadens scope usefully rather than padding.

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 analysis tool with no output schema and no annotations, the description covers what it does but not what an agent gets back (file/line locations, severity, confidence) or any invocation constraints. Adequate but with visible 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?

The tool takes zero parameters, so there is no parameter semantics to explain. Baseline 4 applies; the description cannot add parameter meaning that does not exist.

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 ('Scan') and resource ('N+1 query patterns or heavy database usage') scoped to 'the indexed code'. This clearly distinguishes it from generic siblings like axon_pro_query or axon_pro_search_code, though it doesn't name a sibling explicitly.

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

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

No guidance on when to reach for this tool versus the other 14 analysis tools, no prerequisites (e.g., does the code need to be indexed first?), and no exclusions. Usage is only inferable from the purpose itself.

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 full behavioral burden, and it does partially discharge it by disclosing the scope of data returned. It never states that this is a read-only/non-destructive operation, nor does it mention performance, traversal depth, or cost characteristics that matter for a graph-expansion 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?

A single sentence with zero filler, and the most important information (what the tool returns) is front-loaded immediately after the verb. Nothing could be trimmed without losing meaning.

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

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

With no annotations and no output schema, the description does the work of telling the agent what categories of results to expect, which is the key missing structured information. It is nearly complete for a one-parameter read tool, though a brief note on read-only behavior would close the remaining gap.

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

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

There is a single parameter with 100% schema description coverage ('Name of the symbol to look up'), so the schema already fully documents it. The description reinforces that the input is a symbol but adds no format, scoping, or qualification detail beyond what the schema provides.

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

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

The description pairs a specific verb (Get) with a specific resource (a symbol) and enumerates exactly what is retrieved: callers, callees, type references, and community membership. It is clear on its own, but it does not explicitly contrast itself with overlapping siblings like axon_pro_impact or axon_pro_related_files.

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 '360-degree view of a symbol' implies this is the broad, all-in-one lookup to reach for when you want general context about a symbol, which is a usable implied cue. However, it names no alternatives and states no when-not conditions, leaving the agent to guess how it differs from impact, related_files, or file_context.

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

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

With no annotations, the description carries the full behavioral burden and delivers almost none of it. It does not say whether the query is executed read-only or whether write clauses (CREATE/DELETE/MERGE) are permitted, nor whether there are timeouts, row limits, or permission requirements — critical for a tool that accepts arbitrary query text.

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 filler. It is tight, though the brevity borders on under-specification rather than disciplined conciseness.

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 raw-query tool with no annotations and no output schema, the description should at minimum convey the graph's domain model (nodes/relationships), read/write safety, and result shape. None of that is present, leaving the agent to guess at invocation safety and expectations.

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?

One parameter at 100% schema description coverage, so the schema already documents the 'query' string fully; the description adds nothing beyond 'Cypher query to execute.' Baseline 3 is appropriate when the schema does the work.

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 ('Execute') and resource ('raw Cypher query against the knowledge graph'), and the word 'raw' implicitly distinguishes it from the structured sibling axon_pro_query. It stops short of explicitly naming that sibling, but the purpose 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?

No guidance on when to reach for raw Cypher versus the many specialized siblings (axon_pro_query, axon_pro_impact, axon_pro_dead_code, etc.) that presumably cover common graph questions. An agent has no signal about whether this is a last-resort escape hatch or a primary interface.

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. 'List' implies read-only, but nothing is said about whether results depend on a prior scan being run, the scope of analysis, or cost/latency for a whole-repository sweep. These are exactly the traits an agent needs before invoking it.

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 no filler. It is efficient, though it errs toward under-specification rather than saying something genuinely useful per word.

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

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

No output schema and no annotations, yet the description says nothing about the shape of the result (file/line grouping, confidence levels) or whether a prior analysis pass is required. For a repo-wide analysis tool, that leaves the agent guessing on both preconditions and output.

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 nothing for the description to disambiguate; baseline 4 applies. No syntax or format detail is needed or missing here.

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: 'List all detected dead code in the repository.' No sibling covers dead code, so the resource itself differentiates it, but the description never explicitly positions it against the analysis siblings (axon_pro_query, axon_pro_search_code).

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 when-to-use guidance, no prerequisites, and no mention of alternatives. An agent cannot tell from this text whether it should reach for this tool or a general search/query sibling to find unused code.

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 full behavioral burden. It implies a read-only analysis that returns affected symbols, but says nothing about repository prerequisites, whether the diff must be staged/unstaged, cost, or failure modes for a multi-sibling static-analysis 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 with the action front-loaded and no filler. It is efficient, though the second sentence largely restates the first's implication of impact analysis.

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

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

For a tool with no annotations and no output schema, the description omits what the 'affected symbols' result actually looks like, its granularity, and any prerequisites. That leaves an agent unable to predict the response shape or preconditions.

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

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

There is a single required parameter with 100% schema description coverage, so the schema already defines 'diff'. The description adds no format constraints (whole git diff vs hunks) beyond the schema's own text, 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: 'Analyse code changes in a diff and find affected symbols.' An agent knows it takes a diff and returns impacted symbols, though it never contrasts itself with the closely related sibling axon_pro_impact.

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?

'Helps understand the impact of recent modifications' implies when to use it, but there is no explicit when/when-not guidance and no mention of how it differs from axon_pro_impact or axon_pro_impact_on_tests, which an agent must otherwise guess.

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 the output format (natural language, categorizing downstream actions), which is useful, but does not disclose whether the operation is read-only, whether the symbol must exist, or any other constraints. This is a significant gap for a tool with zero annotation 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?

A single sentence that is front-loaded and free of filler. Every word contributes to stating the purpose and output.

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

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

For a simple one-parameter tool with no output schema, the description explains what the tool does and what it returns. However, it omits usage guidance relative to siblings and does not compensate for the absence of annotations by stating safety or prerequisites.

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 one parameter, so the schema fully documents the symbol parameter. The description does not add any syntax or format details 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?

States a specific verb (Explain) and resource (execution flow of a symbol) and describes the output (natural language, categorizing downstream actions). It does not differentiate from the sibling axon_pro_flow_trace, so an agent must infer which to use from the name alone.

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 no explicit when-to-use guidance, prerequisites, or alternatives. The agent is left to infer that this tool is for explaining flows rather than tracing or impacting them, but no conditions or exclusions are 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?

No annotations are provided, so the description carries the full behavioral burden, and it says almost nothing beyond the one-line purpose. It does not disclose whether the file must exist, error behavior for a missing/invalid path, output size, or any permission or performance characteristics.

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 short sentence with the core action and result front-loaded and no filler. It is efficient, though it is terse enough to leave gaps rather than being an exemplary compact definition.

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

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

For a one-parameter tool with no output schema, the description should explain what 'full context' and 'symbols' concretely mean, since there is no structured return value to inspect. It partially compensates by naming the return content but still leaves the shape of the output undefined.

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

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

Schema coverage is 100% with a single documented parameter ('Path to the file'), so the schema does the heavy lifting and the baseline of 3 applies. The description adds no syntax, format, or path-resolution detail 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?

States a specific verb ('Get') and resource ('full context for a specific file') plus the payload ('all its symbols'), so the agent knows what it retrieves. It does not, however, differentiate itself from close siblings like axon_pro_context or axon_pro_related_files, which an agent must disambiguate on its own.

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 when-to-use guidance, no prerequisites, and no mention of alternatives among the many sibling context/query tools. The agent is left to infer when this tool is preferable to axon_pro_context or axon_pro_search_code.

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 adds the directional qualifier 'downstream,' which is mildly useful, but says nothing about traversal cost, output shape, cycle handling, or what 'understand its behavior deeply' concretely returns.

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 no wasted words. It is efficient, though its brevity borders on under-specification for a graph traversal tool rather than being optimally sized.

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

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

With no annotations and no output schema, the description should explain the return structure (call chain, tree, graph) and the downstream-vs-upstream scope, but it does neither. 'Understand its behavior deeply' is filler that leaves the agent without enough to call the tool confidently.

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 'symbol' and 'depth' are already documented in the schema. The description only echoes the symbol parameter and adds no format or semantics beyond the schema, making the baseline 3 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 ('Trace') and resource ('execution flow downstream') with a clear scope ('starting from a specific symbol'). However, it does nothing to distinguish itself from the near-identical sibling axon_pro_explain_flow, leaving the agent to guess which flow tool applies.

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 guidance on when to use this tool versus alternatives, despite several plausible siblings (axon_pro_explain_flow, axon_pro_impact, axon_pro_context). No prerequisites, exclusions, or selection criteria are given.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Find' implies a read-only analysis, but nothing states whether the traversal is expensive, whether results are transitive or direct, or how depth affects scope. This leaves significant behavioral gaps 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?

A single, front-loaded sentence with a label-style lead-in ('Blast radius analysis:') and zero wasted words. Appropriately sized for a two-parameter tool, though very minimal.

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 two-parameter tool with no output schema, the description suffices to convey what it returns (affected symbols) but omits depth semantics and relationship type, which matter for blast-radius interpretation. Adequate but with clear gaps.

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

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

Schema description coverage is 100%, so both parameters (symbol and depth) are already documented in the schema, establishing a baseline of 3. The description adds no syntax, format, or semantics beyond what the schema provides (e.g., it never explains what depth controls conceptually).

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 all symbols affected by changing a given symbol', framed as blast-radius analysis. This is clearly distinct from siblings like query, context, or dead_code, though it does not distinguish itself from the very close sibling axon_pro_impact_on_tests.

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 no when-to-use or when-not-to-use guidance and names no alternatives, despite a near-identical sibling (axon_pro_impact_on_tests) that an agent could easily confuse it with. The agent must infer the selection criterion on its own.

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 full behavioral burden. The word 'might' hints that results are heuristic, which is a small plus, but the description omits whether this is a safe read-only operation, how the impact is computed (direct callers vs. transitive), and any latency or result-size characteristics for a repo-wide test-impact scan.

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 analytical target front-loaded. Nothing is redundant or padded.

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 low-complexity, single-parameter read-only tool with no output schema, the description is minimally sufficient but leaves key questions open: what 'affected' means in scope, how to interpret heuristic results, and when to prefer axon_pro_impact. It is adequate, not 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 description coverage is 100% for the single 'symbol' parameter, so the schema already documents it fully. The description adds no format guidance (e.g. fully-qualified name vs. simple name) beyond what the schema provides, 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?

The description states a specific verb and resource: 'Identify which tests might be affected by changing a specific symbol.' An agent knows this is test-impact analysis rather than generic impact analysis. However, it never distinguishes itself from the sibling axon_pro_impact, which likely overlaps heavily, so it fails the sibling-differentiation bar for 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 when-to-use guidance, no mention of the closely related axon_pro_impact sibling, and no stated conditions or prerequisites (e.g. symbol must exist in the indexed repo, or that only 'impacted' tests within the analyzed graph are returned). The agent must infer usage entirely.

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 it does convey the basics: 'List' implies a non-mutating read and 'with their stats' hints at the payload. It does not disclose pagination, ordering, or scope limits (e.g. whether only repos visible to the caller are returned).

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 no filler. Nothing could be removed without losing information.

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

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

For a minimal zero-param read tool this is close to sufficient, but with no output schema the description should say more about what 'stats' includes and whether the list is complete or limited, since the agent cannot fall back on structured return documentation.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. No parameter semantics are required or missing.

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 ('List all indexed repositories') plus the returned payload ('their stats'). None of the siblings (query, impact, cypher, dead_code, etc.) do repository enumeration, so the tool is easy to tell apart, though the description never explicitly names that distinction.

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

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

Usage is only implied: a zero-parameter listing tool is obviously a discovery/entry point, but the description gives no explicit when-to-use, no prerequisites, and no pointer to a follow-up tool such as axon_pro_query or axon_pro_architecture.

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 full behavioral burden. It does disclose a non-obvious trait — that matching is hybrid keyword + vector rather than plain substring — and that results are ranked, but it omits read-only confirmation, ranking/scoring semantics, and any result-count or truncation behavior beyond the limit parameter.

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 action and mechanism, with zero filler. Every clause earns its place.

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

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

For a two-parameter read-only search with no output schema, the description covers the essentials (mechanism, ranked return), but it leaves the agent unable to decide between this and sibling search tools and says nothing about what a returned 'symbol' contains.

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% (query text, limit with default 20), so the schema already documents both parameters. The description adds no query syntax, matching-mode, or limit-interaction detail, so 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 (search) plus resource (knowledge graph) and even the retrieval mechanism (hybrid keyword + vector), and names the return type (ranked symbols). It is clear on its own, but it never distinguishes itself from near-neighbors like axon_pro_search_code or axon_pro_cypher, which an agent could plausibly pick instead.

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 when-to-use guidance, no exclusions, and no mention of alternatives despite 15 siblings including several other search/retrieval tools. The agent must infer that this is the semantic/hybrid graph search while search_code and cypher exist for other cases.

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 full behavioral burden. It implies a read-only lookup through the verb 'Find' but does not disclose permissions, side effects, output format, missing-file behavior, or what constitutes structural versus temporal coupling.

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

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

The description is a single, front-loaded sentence with no wasted words. It states the action, resource, and relational scope 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?

For a simple one-parameter lookup tool, the description is minimally adequate. However, without annotations or an output schema, it leaves behavioral and interpretive gaps—particularly around what structural/temporal coupling means and what the returned file list represents.

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% for the single parameter, and the schema already documents 'file_path' as the path to the reference file. The description adds no syntax, format, or constraint details beyond the schema, so the baseline score of 3 applies.

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

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

The description uses a specific verb ('Find') and resource ('files') and adds a clear relational qualifier ('structurally or temporally coupled to a given file'). It is distinguishable from generic search tools, though it does not explicitly name or contrast with sibling tools such as axon_pro_context or axon_pro_impact.

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

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

The description states what the tool does but gives no explicit guidance on when to use it, when not to use it, or which sibling tools are alternatives. The implied usage is present only through the tool's purpose, similar to a minimally documented mutation 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?

No annotations are provided, so the description carries the full burden. It implies a read-only search but does not disclose authentication requirements, rate limits, result format, pagination, whether pattern supports regex, or any safety profile. Only the basic action is stated.

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 no filler. It is appropriately concise, though its brevity leaves no room for structured guidance; structure is clean but minimal.

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 search tool with no annotations and no output schema, the description is too thin. It omits usage alternatives, behavioral traits, and result characteristics, leaving the agent without enough context to select it confidently among many 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?

Schema coverage is 100%, so both parameters are documented in the schema. The description adds minor context by mentioning literal snippets and indexed content, but does not explain pattern syntax (regex vs literal) or limit behavior beyond the schema. Baseline 3 applies.

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

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

The description states a specific verb ('Search') and resource ('code patterns or literal snippets') and scope ('indexed content'). It is clear what the tool does, but it does not differentiate itself from sibling tools like axon_pro_query or axon_pro_cypher, so it cannot earn 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?

No when-to-use guidance or alternatives are provided. The description does not say when to choose this tool over axon_pro_query, axon_pro_cypher, or other search-related siblings, leaving routing to inference.

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