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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It provides none: no indication of whether this is read-only, what permissions are needed, whether it mutates state, or what it returns. The alias relationship is identity metadata, not behavioral transparency.

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 single sentence is efficient and front-loaded, with no wasted wording. However, its brevity reflects under-specification rather than appropriate conciseness for a tool with two parameters and no annotations.

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 alias relationship gives enough context to redirect to the canonical sibling, but the definition is otherwise incomplete for a callable tool. With no annotations, no output schema, and 0% schema coverage, the description should explain the operation, parameters, and expected behavior but does not.

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%, and the description adds no meaning for either repo_path or target_file. An agent must infer from parameter names alone what these inputs should contain.

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 only states that this is a legacy alias for localvibecode_blast_radius. It does not say what the tool actually does, what a blast radius means here, or what operation is performed. Naming the sibling helps identify the relationship, but the purpose remains largely 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?

Calling it a "legacy alias" implicitly signals that the canonical localvibecode_blast_radius should be preferred, which is some routing guidance. However, it never explicitly says when to use this alias, when not to use it, or what deprecation behavior to expect.

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, yet it discloses nothing about side effects. A 'build_graph' tool plausibly writes build artifacts or indexes a repo, and none of that — write behavior, permissions, output location — is stated. 'Legacy alias' alone does not tell an agent what calling it actually does.

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, so it is concise, but conciseness here comes at the cost of under-specification. The alias relationship is front-loaded, which is the right lead, but there is no follow-up substance.

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 an undocumented required-ish path parameter, no annotations, and no output schema, the description should explain what is built and where. It does none of that and leaves the agent to open the sibling tool's definition to learn anything.

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

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

The single parameter repo_path has 0% schema description coverage and the description says nothing about it — no format, whether it is a local path vs a URL, whether it defaults to cwd given that it is not required. The description provides zero compensation for the coverage gap.

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

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

It states the tool is a 'legacy alias' for localvibecode_build_graph, which clarifies its identity and points to the canonical tool, but it never says what a build_graph does — what graph, over what, producing what. The purpose beyond the alias relationship is inferred only from the name.

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?

Calling it a 'legacy alias' implicitly routes the agent toward localvibecode_build_graph instead, which is genuinely useful. But there is no explicit 'prefer X' instruction, no statement of when this alias would still be needed, and no prerequisites.

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 and largely fails it — nothing about side effects, permissions, mutability of repo_path, or what a 'PEV run' produces. The only behavioral hint is that it behaves identically to localvibecode_pev_run, which is indirect at best.

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 single sentence is efficient with no filler, but it is under-specified rather than concise — it spends its one clause on provenance rather than on what the tool does or needs. Brevity here comes at the cost of usability.

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 a required free-form parameter, an optional path parameter, no annotations, and no output schema, the description supplies essentially none of the context an agent needs to invoke it correctly. It doesn't even confirm whether the two tools are fully interchangeable.

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%, and the description says nothing about either parameter. The required 'requirement' string and the optional 'repo_path' are completely undefined — no format, no examples, no distinction between them.

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 only states that this is a 'legacy alias for localvibecode_pev_run' — it never says what the tool actually does (e.g., runs a plan-execute-verify cycle, mutates a repo). It does identify the canonical sibling, but an agent still cannot tell the operation's purpose from this text 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?

'Legacy alias' implies the agent should generally prefer localvibecode_pev_run, which is implicit routing guidance and is the one genuinely useful piece of information here. However, it never explicitly says 'use localvibecode_pev_run instead' or explains when, if ever, this alias should still be invoked (backward compatibility, existing scripts, etc.).

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 about behavior: no indication of whether this is read-only, what it reads or mutates, whether it requires a built graph first, or what it returns. Pointing at another tool's name is not behavioral disclosure.

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 no filler and the key fact (alias, and of which tool) front-loaded. It is efficiently sized — the problem is missing content, not verbosity.

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, no output schema, an undocumented parameter, and no statement of what verification means or what happens on failure, the definition is not sufficient to invoke confidently. The agent is forced to open localvibecode_verify to learn anything substantive.

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 one parameter, repo_path, with 0% schema description coverage, and the description says nothing about it. The agent must infer whether it is a filesystem path, a repo identifier, an absolute vs relative path, or whether it is optional/defaults to cwd.

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 only that this is a 'Legacy alias for localvibecode_verify' — it identifies the relationship to a sibling but never says what the operation actually does (verify what? builds? code?). An agent knows where to redirect but not the capability 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?

'Legacy alias' implicitly signals that new work should go to localvibecode_verify, and that sibling is named explicitly. However, it never states when this alias is still appropriate (existing configs? backwards compat?) versus simply always preferring the canonical 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 exist, so the description carries the full burden. It usefully discloses scope and behavior: bodies are stripped and output is capped under 4,000 tokens, which tells the agent what it will and won't receive. It says nothing about read-only nature, side effects, permissions, or repo_path resolution, leaving real gaps for an unannotated 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?

One dense sentence with the return contents front-loaded and no filler. Minor deduction for the unexplained capitalized term 'Surgical Context', which reads as internal jargon rather than actionable phrasing.

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?

Since there is no output schema, the description correctly spends its words describing what comes back (target code, outbound signatures, inbound callers), which is genuinely useful. However, with no annotations and one of two parameters undocumented, an agent still lacks enough to invoke it confidently across repositories.

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

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

Schema coverage is only 50%: target_file is documented in-schema, but repo_path is undocumented in both the schema and the description. The description mentions only the 'target file' and gives no indication of what repo_path means (default repo? absolute path?) or how it interacts with target_file. With half the parameters opaque, the description fails to compensate.

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 action (extract context) and enumerates the three components returned: target code, 1-hop outbound signatures with bodies stripped, and 1-hop inbound callers. The 'blast_radius' name is ambiguous, but the description resolves it. It does not differentiate from the near-duplicate sibling aisdlc_blast_radius or from localvibecode_build_graph, so it stops short of a 5.

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

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

The token budget ('< 4,000 tokens') and 'surgical context' framing imply this is for cheap, targeted context gathering rather than full graph traversal, which hints at when to use it. There is no explicit when-to-use, when-not, or named alternative among the seven siblings, so usage must be inferred.

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 at all, the description carries the full disclosure burden, and it does add two genuinely useful traits: the build is deterministic and costs '0 LLM tokens'. It does not say where the graph is written, whether an existing graph is overwritten, how expensive/slow it is, or whether it must run before blast_radius — real gaps for a build/index operation.

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-loaded with the action and immediately followed by the returned artifacts. Slightly jargon-dense ('Graphify', 'Architectural God Nodes') and every clause earns its place, though a non-initiated agent may not know what a 'God Node' is.

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, so the prose carries the return-value burden — and it does list the three artifact types, which helps. But for a tool that presumably writes an index to disk, the definition omits persistence location, staleness/invalidations, and the default repo behavior, leaving the agent short of what it needs to sequence this 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% and the single parameter is optional with a self-explanatory schema description, so the baseline is 3. The description adds nothing about what happens when repo_path is omitted (current working repo? cwd?), which is the one meaningful semantic question for a 0-required-param tool.

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 gives a specific verb+resource ('Build/refresh the deterministic AST Code Knowledge Graph') plus a named artifact ('Graphify'), which is far more than a tautology. However, it never distinguishes itself from the identical-looking sibling 'aisdlc_build_graph', so an agent cannot tell which one to pick from the description 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?

There is no explicit 'use when' / 'do not use when' guidance and no mention of the sibling alternatives (blast_radius, verify, pev_run). The only implicit signal is 'refresh', which hints that it should be run before graph-dependent tools, but the agent must infer that.

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. It adds useful architectural detail (deterministic pipeline, fresh context isolation, single local model), but says nothing about whether it writes files to repo_path, whether changes are reversible, expected runtime, or model/resource requirements for a clearly mutating code-generation 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 that leads with the action and then qualifies the mechanism. It is dense with jargon but nothing is padded or redundant.

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 code-mutating pipeline tool with no annotations, no output schema, and an undocumented repo_path, the definition leaves the agent without the information needed to invoke it safely or interpret results. It should state side effects on the repo, return shape, and 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 coverage is only 50%: requirement is documented in-schema, but repo_path has no description anywhere. The description never explains what repo_path means, whether it is optional, or what happens when it is omitted — the exact gap the description should fill for a low-coverage 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 (Execute) and resource (a task) and names the mechanism: a deterministic Plan -> Execute -> Verify pipeline against one local Ollama model. An agent can tell this is the full-pipeline entry point rather than a single-step tool like localvibecode_verify. It does not, however, distinguish itself from the sibling aisdlc_pev_run, which appears to be the analogous pipeline runner.

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 (does a repo need to exist at repo_path? does a graph need to be built first?), and no routing between this tool and aisdlc_pev_run or the localvibecode_verify/blast_radius siblings. The agent must guess which pipeline runner applies.

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

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

With no annotations, the description carries the full burden, and it does disclose useful traits: the verification is 'deterministic' and 'Zero-Token', implying no LLM cost. However, it says nothing about whether it requires a resolvable repo, whether it writes artifacts, how failures are surfaced, or what the result looks like.

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

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

A single front-loaded sentence with no filler; the parenthetical enumeration of checks is compact and informative rather than redundant.

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 outcome contract (per-check pass/fail, error reporting) and the meaning of repo_path. It explains only what is run, leaving the agent without enough to interpret results or call it reliably.

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

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

The single parameter repo_path has 0% schema description coverage, and the description never mentions it, so an agent gets no guidance on whether it is required, what path form is expected, or what defaults apply when omitted (required=false). The schema alone is insufficient 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?

The description uses a specific verb ('Run') plus a named capability ('Zero-Token Deterministic Verification') and enumerates the three checks performed (AST syntax check, Security SAST, Unit Tests). This is clearly distinct from siblings like build_graph or blast_radius, though it never explicitly contrasts itself with the near-identical aisdlc_verify or the pev_run 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 invoke this versus alternatives such as localvibecode_pev_run, aisdlc_verify, or the build_graph/blast_radius tools. The agent must infer that verification happens after a change, and there is no mention of prerequisites or exclusions.

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