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

No annotations and no output schema, so the description carries the full burden. It doesn't say what the 'architecture summary' contains, how large it is, whether 'native CBM' differs from anything else, or what detail=compact/full changes in behavior. Only the read-only nature is implied by 'Return'.

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 compact sentence with the primary resource front-loaded and the scope variant trailing. Nothing is wasted, though 'native CBM' is unexplained terminology rather than useful content.

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

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

A 4-parameter architecture-query tool with no annotations, no output schema, and zero schema descriptions needs a description that covers the aspect/detail model and what comes back. One sentence leaves the agent unequipped to choose aspects or interpret the result.

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

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

Schema description coverage is 0% across 4 parameters; the description only explains `project`. `path`, `detail` (compact/full) and especially `aspects` with 13 undocumented enum values (dependencies, hotspots, layers, clusters, etc.) get no meaning from either the schema or the description — a serious gap for a tool whose main purpose is aspect selection.

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+resource: 'Return the native CBM architecture summary' with an explicit scope toggle ('space snapshot, or one project when project is provided'). It doesn't differentiate itself from siblings like get_graph_schema or query_graph, and 'CBM' / 'native' are undefined jargon, which keeps it below 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 statement of when to use this versus the many graph/code siblings (get_graph_schema, query_graph, search_graph, trace_path). The only usage-like clause ('when project is provided') is really a parameter behavior note, not guidance on selecting 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?

No annotations are provided, so the description carries the full disclosure burden. 'Lookup' implies a read, but it says nothing about return shape, cost, indexing requirements, or what include_neighbors does behaviorally, leaving key traits unstated.

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 padding, which is good, but its brevity comes at the cost of under-specification rather than being efficient density.

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 3-parameter tool with no annotations and no output schema, the description should explain scope semantics and return behavior. It leaves an agent unable to predict what the snippet response contains or what the boolean flag changes.

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 0% across 3 parameters. The description only covers qualified_name via the phrase 'qualified symbol name' and says nothing about 'project' scoping or 'include_neighbors', so the undocumented parameters remain ambiguous.

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 verb ('run lookup') and resource ('code snippet') scoped by 'qualified symbol name', so the core action is inferable. However, 'native CBM snippet lookup' is unexplained jargon, and nothing distinguishes this from sibling tools such as search_code or read_snapshot_file.

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

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

There is no statement of when to use this instead of search_code or the other snapshot/graph readers. The phrase 'qualified symbol name' weakly implies it operates on indexed symbols, but no prerequisites, exclusions, or alternatives 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?

With no annotations and no output schema, the description carries the full behavioral burden. "Return" implies a read operation, but the description does not disclose permissions, default scope when no project is supplied, return format, or whether the snapshot must already exist.

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

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

It is a single front-loaded sentence with no filler or repetition. However, the brevity leaves no structure for explaining scope, defaults, or return behavior.

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, no output schema, and an undocumented optional parameter, the one-sentence description is not complete enough. It identifies the resource but leaves return shape, default behavior, and parameter meaning unspecified.

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

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

Schema coverage is 0% for the single optional project parameter, and the description never mentions it. The phrase "this space snapshot" hints at scoping, but it does not explain what project selects or what happens when it is omitted.

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, "Return," and a specific resource, "native CBM graph schema details," scoped to a space snapshot. It is clearer than a tautology, but it does not explain what CBM means or distinguish itself from siblings such as get_architecture.

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, exclusions, or alternatives. It does not tell the agent how this schema-inspection tool relates to get_architecture, query_graph, or search_graph.

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 does not meet it. It never states that this is a read-only/non-mutating check, what the possible status values are, whether indexing is per-project or shared, or any cost/latency/auth considerations.

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; the scope qualifier follows the action efficiently. Slightly penalized only because the unexplained 'CBM' term consumes words without adding clarity.

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

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

The tool is simple (one optional parameter), so the description covers the core call pattern. But with no output schema and no annotations, it should say what a status result looks like (e.g., indexed/pending/failed) and how the whole-snapshot result relates to per-project results; those gaps matter for correct interpretation.

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

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

Schema coverage is 0% — the single `project` parameter has no description, so the description must compensate. It does add real meaning by noting that `project` selects one project inside the space snapshot and that omitting it targets the snapshot as a whole, but it does not say whether the value is a project name, slug, or ID.

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 (Check) and resource (CBM indexing status) plus the scope it applies to: the space snapshot or a single project inside it. However, it never distinguishes itself from the sibling snapshot_index_coverage, which appears to cover very similar ground, and leaves the 'CBM' acronym unexplained.

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

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

The description implies the two usage modes (omit `project` for whole-snapshot status, pass it for a single project), so some usage context is inferable. But it gives no explicit when-to-use guidance and no exclusion or alternative routing versus snapshot_index_coverage, leaving the agent to guess which tool to pick.

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 a read-only operation, and the snapshot scoping adds useful context, but the description does not state permissions, ordering, empty-result behavior, or the shape of returned project entries.

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

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

The definition is a single well-formed sentence with the verb and scope front-loaded. There is no redundant or filler material.

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 zero-parameter list tool this is close to adequate, but with no output schema and no annotations, the description leaves the return format unspecified. An agent knows what is listed but not what a returned project record contains or how results are ordered.

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

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

The tool has zero parameters, so the baseline is 4. There are no parameters whose meaning needs to be explained beyond what the empty schema already conveys.

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 clear verb (List) and resource (CBM projects) plus a scope (inside this MemoRepo space snapshot). It distinguishes itself reasonably from file-oriented siblings like list_snapshot_files, though it does not explicitly name a sibling or define what a 'CBM project' is.

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: an agent can infer this is the tool for enumerating projects within a snapshot. There is no explicit when-to-use guidance, no mention of when not to use it, and no comparison to list_space_repositories or snapshot_index_coverage.

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 discloses important traits such as immutable snapshots, relative-path results, prefix/glob filtering, and offset pagination, but it does not cover permissions, snapshot/index prerequisites, error behavior, or what happens when no snapshot exists.

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 tight sentences front-load the purpose and then add usage and filtering/pagination details. There is no redundant or filler language.

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

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

The description covers the core purpose, usage, return shape, filtering, and pagination, which is substantial. However, for a five-parameter tool with no annotations and no output schema, it leaves gaps around project semantics, limits, and operational 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 0%, so the description must compensate. It explains prefix/glob filtering and offset pagination, and implies the snapshot/project scope, but it does not clarify the required project parameter or the limit cap.

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: 'List regular files captured in one repository's immutable snapshot tree.' It also scopes the result to relative paths and distinguishes the tool's purpose from reading or searching snapshot contents.

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 clear usage contexts: file inventories and extension/path existence questions. It does not explicitly name alternatives such as search_snapshot_text or read_snapshot_file, but the intended use is unambiguous.

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 behavioral burden and discloses the key non-obvious trait: output is compact by default and branches/detailed metadata are opt-in. It omits any mention of permissions or side effects, but as a 'list' operation those are largely self-evident.

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 concise sentences, front-loaded with the primary action and followed by the key output-shape caveat. No wasted text.

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

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

For a simple two-flag list tool without an output schema, the description gives enough to call it correctly: what is listed and what is omitted by default. A bit more on parameter names/defaults would make it fully complete.

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

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

Schema description coverage is 0%, so the description must compensate. It explains that branches and detailed metadata are omitted unless requested, which maps loosely onto include_branches and include_details, but it never names the parameters or states their defaults explicitly.

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 compact repositories and project names for this MemoRepo space.' Clear what is returned, though it does not distinguish itself from sibling list_projects or snapshot 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?

The line 'Branches and detailed metadata are omitted unless explicitly requested' implies when to enable the optional flags, but there is no explicit guidance on when to choose this over list_projects or list_snapshot_files. Usage is only implied.

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 zero annotations, the description does real work: it declares read-only execution, warns that only a 'supported subset' of Cypher is accepted, and flags that max_rows is a global cap for projectless calls. It omits what happens on unsupported constructs (error vs. silent truncation), whether the snapshot is a fixed point-in-time view, and any return shape, which are the biggest risks for a query language 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?

Three short sentences, all front-loaded with the highest-value fact (read-only Cypher against a space snapshot) first, then the constraint, then pagination. No filler and nothing buried.

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 annotations and no output schema mean the description carries the burden, and it covers safety profile, language restriction, row caps, and pagination reasonably well. It falls short on the undocumented project parameter and on sibling routing, both of which an agent needs before writing Cypher.

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 0%, so the description must compensate, and it does for three of four parameters: max_rows gets both its 1-25 range and its projectless-global-limit semantics, offset gets its pagination role, and query is scoped to a read-only Cypher subset. The 'project' parameter is never explained — notably the phrase 'projectless calls' hints at scoping behavior without stating what setting project actually changes — which is the one real gap.

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

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

Specific verb and resource: 'Run the supported read-only Cypher subset against this space snapshot' tells an agent exactly what the tool does and the query language involved. It does not distinguish itself from siblings like search_graph or trace_path, so the agent gets no signal about why one would choose Cypher over those higher-level 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?

There is no guidance on when to use this tool versus search_graph, trace_path, or get_graph_schema, and no note that a schema-discovery call should precede arbitrary Cypher. 'Use offset for scoped pagination' is parameter mechanics, not tool-selection guidance, so the agent must infer applicability 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 does meaningful work: it discloses UTF-8 encoding, that the target must be a regular file, that the snapshot is immutable, that reads are bounded, and that digest and truncation metadata accompany results. It does not cover error behavior, permission requirements, or what happens with non-regular or binary paths, so it is not fully complete.

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. Every clause (bounded, numbered, UTF-8, regular file, immutable snapshot, digest/truncation metadata) adds distinct 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 five-parameter tool with no annotations and no output schema, the description gives a reasonable behavioral sketch and notes return metadata, but it omits defaults, error cases, and parameter definitions that an agent would need to call it correctly. It is minimally adequate rather than 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 0%, so the description must carry parameter meaning. It hints at line bounds ('bounded numbered lines') and byte limits ('truncation metadata'), but it never defines project, path, start_line, end_line, or max_bytes explicitly, nor their defaults, 1-based numbering, or units. This leaves most parameter semantics for the agent to guess.

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: 'Read bounded numbered UTF-8 lines from a regular file in one immutable repository snapshot.' This makes it distinguishable from list_snapshot_files and search_snapshot_text by specifying line-range reading of a single file rather than listing or searching. However, it does not explicitly contrast itself with the other content-retrieval siblings.

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

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

Usage is implied by the phrase 'Read bounded numbered UTF-8 lines from a regular file,' suggesting the tool is for fetching a slice of file content. There is no explicit guidance on when to choose this over search_snapshot_text or get_code_snippet, nor any stated exclusions or preconditions.

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

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

With no annotations, the description carries the full burden. It usefully discloses pagination via offset and a 25-result effective cap, plus a 250-match ceiling for scoped searches, but omits result ordering, read-only/safety profile, and what the response contains. The stated caps are the main behavioral value added.

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?

It is front-loaded and only three sentences, but the sentences mix jargon ("CBM"), pagination, and an out-of-schema field, and the "requested limits above 25" clause is inconsistent with the schema's maximum of 25. Compact but not fully earned.

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 10-parameter tool with no annotations, no output schema, and thin schema descriptions, the description leaves most parameters and the return shape unexplained. It covers caps but not enough for an agent to call this tool confidently across its modes.

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

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

Schema coverage is 0% across 10 parameters, yet the description only touches limit and offset; mode, regex, detail, context, project, path_filter and file_pattern are never explained. It also references "has_more", which is not even an input parameter, creating confusion rather than clarity.

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?

It states a verb and resource ("code text search") scoped to "this space snapshot", but "native CBM indexed" is unexplained jargon and nothing distinguishes it from the sibling search_snapshot_text or search_graph. An agent can guess it searches code text, but not precisely how this differs from the other search 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?

There is no statement of when to use this tool versus search_snapshot_text, search_graph, or trace_path, and no guidance on when to use regex, mode, or detail. Usage is only implied by the word "search".

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, yet it discloses nothing: not the safety profile (read-only implied by 'search' but never stated), not the 25-result cap enforced by the schema, not pagination via offset, and not the return shape.

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?

It is a single sentence with no padding, but at one clause it is drastically under-specified for a 14-parameter tool. Conciseness here is the result of omission rather than tight writing.

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?

A 14-parameter, zero-required search tool with no annotations and no output schema gets only one vague sentence. An agent would have to guess at parameter semantics and result behavior, which is wholly inadequate given the tool's 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 description coverage is 0% across 14 parameters, and the description adds no meaning for any of them. Critical filters such as label, qn_pattern, name_pattern, file_pattern, min_degree/max_degree, relationship, detail, and include_connected are entirely undocumented anywhere.

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

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

The description names a verb ('search') and a resource ('structured graph'), and 'within this space snapshot' gives scope. However 'native CBM' is unexplained jargon, and it does not distinguish this from the sibling query_graph, so an agent cannot tell which of the two graph query tools to pick.

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

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

There is no statement of when to use this tool versus query_graph, search_code, or search_snapshot_text, and no prerequisites or exclusions. The agent must infer routing from the tool name alone.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses that snapshots are immutable, that literal text search includes unindexed files, and that absence conclusions require pagination to completion. It omits permissions, result shape, default behaviors, and error conditions, leaving significant gaps for a tool with no annotations.

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

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

The description is two tight sentences with the core scope stated first and the critical pagination/absence caveat second. Every sentence adds useful information, and there is no filler.

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

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

This is a relatively complex tool with 8 parameters, no annotations, no output schema, and 0% schema description coverage. The description mentions has_more and complete but does not define the return structure or explain most parameters, so an agent would still need to infer too much 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 0% across 8 parameters, so the description must compensate for undocumented fields. It only implies that query is literal and that limit/offset relate to pagination, but provides no semantics for glob, extensions, path_prefix, project, case_sensitive, or the pagination parameters. Coverage gaps remain substantial.

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: search literal text across immutable snapshot files. It also clarifies scope by saying it includes files CBM does not index, which implicitly distinguishes it from indexed code search siblings. It does not explicitly name an alternative such as search_code, so it falls short of 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?

The description gives important procedural guidance: paginate to has_more=false and require complete=true before drawing absence conclusions. However, it does not explicitly say when to use this tool versus search_code, read_snapshot_file, or search_graph. Usage is therefore implied and partially constrained rather than fully guided.

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 must carry full behavioral disclosure. It states that the report includes skips, exclusions, quality, and exhaustiveness, and notes that candidate files are not claimed as proven graph membership, but it does not explicitly confirm read-only behavior, permissions, side effects, or output format.

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 and front-loads the primary purpose before adding the caveat. It is efficient, though the phrase 'CBM graph membership' is jargon that could limit immediate clarity.

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

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

The description lists several report contents and includes an important caveat, which helps for a read-only reporting tool with no output schema. However, it still leaves the optional project parameter, expected output shape, and comparison to sibling tools underexplained.

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 0%, so the single project parameter is undocumented in the schema. The description mentions reporting 'by project,' implying grouping or filtering, but does not explain the project parameter's format, optional nature, or what happens when it is omitted.

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 gives a specific verb and resource: reporting verified source-integrity coverage for an immutable snapshot, broken down by project and file extension. It is clearly a coverage-reporting tool rather than a file-listing or graph-search tool, though it does not explicitly differentiate itself from siblings like index_status or get_graph_schema.

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

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

There is no explicit guidance on when to use this tool instead of alternatives such as index_status, list_snapshot_files, or search_graph. The caveat about candidate files not being proven CBM graph membership is a limitation, not a usage rule.

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 mentions that results include USAGE references, but does not state whether the operation is read-only, what permissions are needed, what happens if the function is not uniquely resolved, or what the output 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?

The description is two short sentences with no wasted words and is front-loaded with the primary action. It is arguably too terse for an 11-parameter graph-tracing tool, but the conciseness itself is effective.

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 11 parameters, no annotations, no output schema, and 0% schema description coverage, the description is not complete enough for an agent to invoke the tool correctly beyond the required function_name. It omits all parameter semantics and most behavioral context needed for tracing modes, direction, depth, and detail.

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 0% for 11 parameters, so the description must compensate. It only hints at function/method resolution and USAGE references, leaving mode, depth, detail, project, direction, edge_types, risk_labels, include_tests, parameter_name, and qualified_name entirely unexplained.

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: 'Trace a uniquely resolved function or method.' It also adds that results include USAGE references for callbacks and functions passed as values. It does not explicitly distinguish the tool from siblings such as query_graph or search_graph, so it falls short of a 5.

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

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

The description does not explain when to use trace_path versus alternatives such as query_graph, search_graph, or get_code_snippet. It implies that this is for tracing resolved functions and callback usage, but gives no usage conditions, exclusions, or alternatives.

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