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 only asserts 'Read-only,' which is a minimal safety hint, but says nothing about the pattern language, mode semantics, path limits, or result 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?

Two fragments are concise but severely under-specified for a three-parameter structural search tool. It is not verbose, but the extreme brevity omits information an agent needs, making the sizing inappropriate rather than efficient.

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, and 0% parameter description coverage, the description is far too sparse. Critical details such as pattern syntax, mode behavior, path constraints, and result format are entirely absent.

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 three parameters, including a 'mode' enum ('text' vs 'query') whose meaning is critical for correct invocation. The description adds no meaning beyond the bare schema, so it fails to compensate 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?

The description gives a specific verb+resource ('Structural AST search'), which is clearer than a generic 'search' sibling. However, it does not differentiate itself from siblings like 'search' or 'lsp_symbols', leaving the agent to infer the structural/AST distinction 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?

No when-to-use guidance, no alternatives, and no conditions are stated. 'Read-only' is a safety property, not usage guidance, so the agent has no direction on when this tool beats 'search' or 'lsp_symbols'.

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. "Stale-safe" and "mutates exactly one file" are useful hints, but it omits what happens on a hash mismatch, whether the patch is atomic/partial, and any permission requirements — key facts for a mutation 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 no padding, and the mutation scope is front-loaded alongside the core purpose. The second sentence is slightly redundant with "single-file" already in the first, but it is not wasteful.

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 single-file mutation tool with no annotations, no output schema, 0% parameter coverage, and a nested patch structure. The description does not cover failure behavior, the role of expected_hash, or the hunk format, so it is well short of complete for this complexity.

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

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

Schema description coverage is 0% across three parameters, including a nested patch.hunks object, and the description explains none of them. "Hashline-style" is unexplained jargon that gestures at the old/new match format but conveys no actionable semantics, and expected_hash is never mentioned.

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 ("Apply") and resource ("hashline-style single-file patch") and scopes it to one file, which separates it from the whole-file fs_write sibling. However, it never names fs_write or any sibling explicitly, so differentiation is inferential rather than stated.

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 at all. It does not say when to prefer this over fs_write, whether expected_hash is required for the stale-safe guarantee, or what the caller should do on failure — the agent must infer all routing decisions.

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

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

Annotations are absent, so the description carries the full burden. 'Read-only' is a useful safety signal, but nothing is said about size limits (max_bytes caps at 1 MiB), offset/paging behavior, or how a missing/unreadable path is handled.

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 scope, with no wasted filler. It is concise but so sparse that brevity shades into under-specification.

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, and three undocumented parameters, the definition leaves too much open. It should at least state that it returns file content plus a fingerprint, and clarify how offset/max_bytes bound the read.

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 mentions no parameters at all. 'single file' faintly implies path, but offset and max_bytes – both non-obvious paging/truncation controls – are completely unexplained, so the description does not compensate 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?

States a specific verb ('Read') and resource ('a single file within the workspace'), and the scope ('single file') implicitly distinguishes it from bulk/search-oriented siblings. It never names fs_stat or search as the alternative for metadata or content search, so sibling differentiation is only partial.

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, no prerequisites, and no alternatives named. The agent must infer from the sibling list whether fs_stat (metadata) or search (content lookup) is the better fit.

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 provided, the description carries the full behavioral burden. It does disclose 'Read-only', which establishes the safety profile, but says nothing about what happens on a missing path, symlink handling, permissions, or what metadata is 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?

Two very short, front-loaded sentences with no filler. It is efficient, though the brevity edges into under-specification rather than pure 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 simple one-parameter read tool with no output schema, minimal coverage is defensible, but the description omits what 'stat' actually returns (size, type, timestamps) and error behavior on missing paths, leaving gaps an agent would need to probe.

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% and the single parameter 'path' has no description in either the schema or the description beyond 'a single path'. No format, relative-vs-absolute, or workspace-relative semantics are given.

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 (stat) and resource (a single path) scoped to the workspace, which is more precise than a generic 'get info'. It does not explicitly distinguish itself from sibling fs_read, but the 'stat/single path' phrasing implies metadata rather than content.

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 use this versus fs_read, workspace_info, or search, and no prerequisites or conditions given. The agent must infer that stat is for metadata inspection.

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, so the description carries the burden. It discloses mutation ('Mutates exactly one file') and a 'stale-safe' property, which usefully signals concurrency protection. However, it omits auth requirements, overwrite semantics, atomicity, or failure modes, and 'stale-safe' is jargon without explanation of what happens on a stale write.

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, front-loaded clauses with no filler. The essential action is stated first, and the modifier is second. Nothing wasted.

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 mutating, three-parameter tool with no annotations, no output schema, and 0% schema coverage, the description is far too thin. It should explain the write semantics, what 'stale-safe' means (role of expected_hash), and overwrite behavior.

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%, so the description must compensate. It mentions 'single file' but says nothing about path, content (including the 8MB maxLength), or expected_hash and what stale-safety has to do with it. The three parameters are functionally undocumented in both schema and description.

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 (Write) and resource (a single file within the workspace), and adds a scope qualifier (single file). It distinguishes from fs_patch (which presumably edits), but doesn't explicitly name that sibling or others, 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?

No when-to-use, when-not-to-use, or alternative routing is provided. An agent can't tell from this whether to pick fs_write, fs_patch, or another sibling for a given edit scenario.

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 discloses that the operation is read-only, which is useful, but says nothing about the required LSP server state, permissions, rate limits, error behavior, or what diagnostics 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?

Two short sentences with the purpose front-loaded and no wasted words. It is efficient, though extremely terse given the incomplete specification elsewhere.

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 read tool with no output schema and no annotations, the description is still too thin. It does not explain what diagnostics are returned, how to interpret them, or whether an LSP session must already be running.

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 says the diagnostics are for a file, implying the path is a file path, but gives no format, relative/absolute expectations, or URI guidance, leaving the single parameter largely undocumented.

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 resource (a file) and purpose (language server diagnostics), making it distinct from siblings such as lsp_symbols and lsp_navigate. However, it does not explicitly name or differentiate against alternatives, so it falls short of the top score.

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, no prerequisites, and no exclusions. The agent must infer usage from the name and description 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, and it delivers only 'Read-only'. It omits whether a language server must already be running (relevant given the lsp_status sibling), how definitions/references/hover are resolved, and any latency or initialization caveats for a language-server-backed call.

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 clauses, front-loaded with the verb and the modes, with no filler. It is efficient, though the extreme brevity leaves useful detail on the table rather than being wasteful.

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 4-parameter tool with no annotations and no output schema, the description is thin: it never explains return shapes for the three modes, prerequisites (server running), or the coordinate parameters. An agent could invoke it but must guess at critical call details.

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, but it only echoes the action enum values already present in the schema. The required 'path' and, more importantly, the line/column coordinates (instantiation base, cursor semantics, when they are required) are left 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?

States a specific verb (navigate) and the three modes (definition/references/hover) executed via a language server, which is clear enough for an agent to know what the tool does. It does not, however, distinguish itself from nearby siblings like lsp_symbols or ast_search, leaving the boundary between them implicit.

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 and no named alternatives, despite several overlapping siblings (lsp_symbols, lsp_diagnostics, ast_search). The only usage signal is the terse 'Read-only' tag, which indicates safety but not selection 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?

No annotations are provided, so the description bears the full behavioral burden, and it delivers only the single phrase 'Read-only.' That is a useful safety signal but nothing about failure modes, latency, whether it depends on an active LSP session, or what the caller learns from a negative result.

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 fragments, front-loaded and waste-free. It is arguably over-terse rather than padded, but nothing is 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 zero-parameter status probe with no output schema and no annotations, the description covers the minimum (what it is plus read-only) but omits what the status actually conveys to the caller. A returning agent gains no expectation about the shape or meaning of 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?

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. No argument syntax, defaults, or filtering options are needed 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?

Names the resource (language server status) and not much else. It doesn't say what aspect of status is reported (running servers, capabilities, readiness) or how it differs from the sibling lsp_diagnostics or lsp_symbols, so an agent must guess at the boundary between this and other LSP 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 indication of when to call this versus the other lsp_* siblings, nor any precondition such as whether a language server must already be attached or how to react when status reports a failure.

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 supplied, so the description carries the full behavioral burden. It does disclose one useful trait — that the operation is read-only — but says nothing about prerequisites (e.g. whether an LSP server must be running), latency, or the shape/size of results for a large file.

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 terse fragments, front-loaded with the resource and no filler. It is not padded, 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 one-parameter tool with no output schema and no annotations, the description should at least say what a "symbol" is in this context (hierarchical document symbols vs flat list) and confirm the path form. Both are missing, leaving an agent to call blindly.

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 the single required parameter. "For a file" weakly clarifies that path refers to a file rather than a workspace or directory, but leaves open whether it is an absolute path, workspace-relative path, or file URI — the exact ambiguity an agent would hit when calling it.

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?

"Symbols for a file" identifies the resource (symbols) and the scope (a single file), so an agent can roughly place it against lsp_diagnostics or lsp_navigate. But it is a verb-less noun phrase — it never says whether it lists, extracts, or resolves symbols, and does not state what kind of symbols (declarations, outline, document symbols). Purpose is implied rather than stated.

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 reference to any sibling tool such as ast_search or lsp_navigate. "Read-only" is a safety trait, not usage guidance. The agent must infer the entire invocation 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. It does disclose 'Read-only', which is genuinely useful, but says nothing about output shape, result limits, path defaults, or how grep and glob differ behaviorally.

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 tight two-clause fragment with the core purpose front-loaded and no wasted words. Terseness borders on under-specification, but nothing is 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 3-parameter tool with 0% schema description coverage, no annotations, and no output schema, the description is too thin. It leaves result format, path behavior, and grep-vs-glob semantics unexplained.

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 only hints at the mode values ('grep or glob'); path and pattern semantics, defaults, and expected formats are left entirely undocumented.

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) and resource (the workspace), and clarifies the two supported modes (grep or glob). However, it does not distinguish itself from the sibling ast_search, which is also a search tool, so an agent cannot tell from the description alone which search 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?

No when-to-use guidance, no exclusion criteria, and no mention of alternatives such as ast_search or the lsp_* tools. The only routing hint is the mode enum, which is already in the schema.

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 provided, the description carries the full behavioral burden, and all it offers is "Read-only." It does not disclose output shape, whether it requires a clean working tree, or whether uncommitted/staged changes are included.

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 terse fragments with no wasted words, but this is under-specification rather than conciseness; the brevity leaves the definition functionally empty.

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 zero-annotation, zero-output-schema tool with an undocumented parameter requires far more from the description than a name restatement and a read-only note. Nothing an agent needs to call this correctly is present.

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 (path) at 0% schema description coverage, and the description never mentions it, so its meaning (file vs directory vs whole repo default) is entirely undocumented. The description does not compensate 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?

"VCS diff" essentially restates the tool name with no verb or explanation of what a diff operation returns. It does not distinguish this tool from sibling vcs_status or from search/fs_read that also surface change-related data.

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 the obvious alternative (vcs_status) or whether a path is needed for a workspace-wide diff. The agent is left to infer everything.

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. "Read-only" is the one useful disclosure (non-mutating), but nothing is said about required auth, repository state assumptions, or what is returned when no repo is present.

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 very short and front-loaded with no filler, which is good, but the brevity comes from under-specification rather than tight editing. Two fragments do not constitute an adequately structured 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 tool with no annotations, no output schema, and an undocumented parameter, this description leaves nearly everything an agent needs unanswered. Only the read-only nature is communicated.

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 never mentions the single `path` parameter. An agent cannot tell whether path means a repo root, a working directory, or a file to scope the status to.

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?

"VCS status" largely restates the tool name vcs_status rather than describing a distinct verb+resource outcome. It does not distinguish itself from the sibling vcs_diff, and an agent learns nothing about what status information is returned.

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 alternatives such as vcs_diff or workspace_info. "Read-only" is a weak implicit hint that this is a safe inspection call, but no context, prerequisites, or exclusions 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 provided, the description carries the full burden. 'Read-only' is a meaningful disclosure about the safety profile, but the tool takes no parameters and no output schema exists, so the description is silent on what is actually returned (paths, config values, roots). It discloses the mutation behavior but little else.

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 zero waste, and the core purpose is front-loaded.

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

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

For a parameterless tool this is nearly complete on mechanics, but with no output schema and no annotations, the description should say what the inspection yields (e.g., workspace root, name, configuration). What an agent gets back is unknown, which is a real 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 the baseline of 4 applies per the rubric. The description correctly implies no arguments are needed.

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 ('Inspect') and resource ('the configured workspace'), so the agent knows it reports on workspace configuration rather than reading or searching files. It doesn't explicitly distinguish itself from siblings like fs_stat or lsp_status, which also report status, 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?

There is no indication of when to call this versus alternatives such as fs_stat (file metadata) or lsp_status (language-server state). Usage is implied by the resource name but no context or exclusions are given.

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