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 the destructive scope explicitly: the collection and all vectors are deleted. It stops short of stating irreversibility, required permissions, or what state the index is left in (e.g., whether a reindex is required), which are the high-value disclosures for a destructive 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 zero filler, and the destructive consequence is front-loaded immediately after the purpose. Every sentence earns its place.

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

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

For a destructive, unreversible-looking operation with no annotations and no output schema, the description covers what is destroyed but omits reversibility, permission requirements, and post-clear state. Adequate but with clear gaps an agent would need to act safely.

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

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

There is a single required boolean, and schema coverage is 100% with the schema itself stating 'Confirmation to clear index (must be true)'. The description adds nothing about confirm, so the baseline of 3 for fully documented parameters applies.

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

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

States a specific verb (clear) and resource (all indexed data / the vector database collection and vectors), so an agent can tell it apart from siblings like search_code or reindex_changed_files. It does not, however, explicitly draw a boundary against reset_state, which is a plausible alternative for wiping state.

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 never says when this should be used versus alternatives such as reindex_changed_files or reset_state, nor does it state prerequisites or consequences for the calling workflow. Usage must be fully inferred from the name.

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 the effect (hooks firing on branch switch, pull, merge) but omits key traits: whether existing hooks are overwritten, required permissions, how to undo/disable, and what happens if the path is not a git repo. 'Install' implies a filesystem mutation that is never characterized.

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; the action is front-loaded and the second sentence explains the payoff without redundancy. Nothing is padded.

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

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

For an unannotated mutation tool with no output schema, the description should cover reversibility, overwrite behavior, and side effects on the target repository. None of that is present, leaving real gaps for an agent deciding whether to invoke it.

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

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

Schema description coverage is 100%, so both parameters (path, hooks enum) are already documented, making 3 the baseline. The description's mention of 'branch switch, pull, merge' loosely maps to the post-checkout/post-merge hook options but adds no syntax or default information beyond the schema.

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

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

States a specific verb and resource ('Install git hooks') plus the outcome ('automatic re-indexing on git operations'). It implicitly differentiates from the manual sibling reindex_changed_files by framing this as the automatic mechanism, but never names siblings explicitly.

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

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

The context of use is implied ('Makes index stay in sync automatically'), so an agent can infer this is a one-time setup tool rather than a per-change tool. However, there is no explicit when/when-not guidance, no prerequisites, and no reference to the alternative of manually calling reindex_changed_files.

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 the dual output mode (live progress while indexing vs. statistics when idle), which is genuinely beyond the schema. However, it never states the operation is read-only/side-effect-free, nor anything about refresh/polling cost, so the safety profile is left to inference from the verb 'Get'.

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, front-loaded with what is returned and followed by the use case. Every sentence contributes; only the quoted 'Shows LIVE PROGRESS...' clause is mildly redundant with the opening statement.

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 read tool with no output schema, the description explains what the return looks like in both states, which is the main thing an agent needs. Lacking an output schema, it could say a bit more about the shape of the statistics, but nothing essential is missing.

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

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

The tool takes zero parameters, so per the rubric the baseline is 4. There are no arguments whose semantics the description could or should elaborate.

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+resource ('Get the current status of the indexed codebase') and clarifies what the status contains (live progress vs. collection statistics). It implicitly separates itself from mutation siblings like index_codebase or clear_index by framing itself as a monitoring read, though it never names a sibling explicitly.

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

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

The final sentence gives clear context: 'Use this to monitor long-running indexing jobs.' That tells the agent when the tool is relevant, but there are no explicit exclusions or named alternatives (e.g., how it differs from search_code for checking collection contents).

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 does well: it discloses the async-by-default execution model, immediate return, and the full pipeline (extraction, embeddings, vector storage). It omits whether re-indexing an existing path overwrites prior data, permission requirements, or rough duration for large repos.

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 sentences, zero filler, and the most operationally important fact (background by default) is front-loaded in the second sentence where an agent will see it.

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 description must stand alone for a mutating tool that writes to a vector store; it covers purpose, mechanism, and the async contract. Gaps remain around idempotency/overwrite behavior and failure modes on an invalid path, which matter for a write operation.

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

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

Schema coverage is 100%, so the baseline is 3; the description earns an extra point by explaining the runtime consequence of the background flag ('returns immediately', status checkable) rather than merely naming it. The path and languages parameters are left to the schema, which already documents them fully.

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 ('Index a codebase for semantic code search') and even enumerates what gets extracted (functions, classes, modules), so the agent knows exactly what this produces. It does not, however, distinguish itself from the sibling reindex_changed_files, leaving the initial-vs-incremental distinction to inference.

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

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

Gives clear operational context: the default is background execution and progress is checked via get_index_status, which is a genuine workflow hint. It stops short of explicit when-not-to-use guidance (e.g., use reindex_changed_files instead of a full re-index, or clear_index first).

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 the actions performed (creates a config file, installs git hooks, starts indexing), which is meaningful transparency for a mutation tool. However, it omits critical traits such as whether it overwrites existing config, idempotency on repeat runs, and side effects on repo state beyond hooks.

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 core action list is front-loaded in a single efficient sentence. The trailing 'One command to set everything up!' is slightly promotional filler, but it is short and does reinforce the composite value proposition, so little is 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 mutation tool with no annotations and no output schema, the description is adequate on the 'what' but thin on operational edge cases: it does not state overwrite behavior, idempotency, or expected duration. The schema fully covers the two parameters, so no return-value explanation is needed, but the behavioral gaps keep it at minimum-viable completeness.

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

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

Schema description coverage is 100%, so both parameters are already documented in the schema, establishing a baseline of 3. The description's mention of 'install git hooks' loosely maps to enableGitHooks but adds no syntax, default, or behavioral detail beyond the schema, so no uplift is warranted.

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 specific verb+resource (onboarding a project) and enumerates the concrete steps: language auto-detect, config creation, git hook installation, and initial indexing. This makes clear it is a composite bootstrap tool, distinguishing it implicitly from narrower siblings like index_codebase or enable_git_hooks. However, it never names those siblings, so differentiation is inferred rather than explicit.

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

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

The phrase 'for a new project' implies the usage context, and 'One command to set everything up' hints it is the convenience alternative to running the individual steps. But there is no explicit when-to-use vs. when-not guidance (e.g., 'for an already-indexed repo, use reindex_changed_files instead'), leaving the agent to infer the routing decision.

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 the mechanism (Merkle trees) and that behavior branches on the files parameter, which is real context. However, it omits permissions/auth needs, how deletions or renames are handled, and whether the operation is safe to repeat — notable gaps for a state-mutating index 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, front-loaded with the core verb and scope, then mechanism, then comparative value. '(fast)' is slightly redundant against the closing sentence, but overall little waste.

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 or annotations exist, so the description must stand alone; it covers what the tool does and its two modes but says nothing about return values, progress/status reporting (a sibling get_index_status exists), or error conditions on a bad path. Adequate but with clear gaps for a 2-param stateful tool.

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

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

Schema description coverage is 100%, so both parameters are already documented, including that files is optional and triggers auto-detection. The description reinforces the mode switch but adds no syntax, format, or path-relative detail beyond the schema. Baseline 3 applies when the schema does the heavy lifting.

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 (re-index) and scoped resource (only changed files), and explicitly frames itself against the full-reindex alternative with 'Much faster than full re-index.' An agent can distinguish it from index_codebase without opening a 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?

The description makes clear when to prefer this over a full re-index and describes the two operating modes (auto-detect vs explicit files). It does not name the sibling (index_codebase) directly or state when a full re-index is required instead, so it falls short of explicit alternative routing.

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 disclosure burden and does state that it kills processes and removes locks/state files, which signals destructive behavior. However, it omits key behavioral facts for a destructive tool: whether anything is irreversible, whether it terminates user processes or only stuck ones, and whether a re-index is required afterward.

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: the first front-loads what the tool does, the second front-loads when to use it. No filler, no repetition of the tool name, and the most decision-relevant content comes first.

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 single-parameter, no-output-schema tool with no annotations, the description covers what it does and when to invoke it, which is close to sufficient. The remaining gap is behavioral: the aftermath (does indexing need to be re-run?) and the irreversibility/permission profile of a destructive reset are not addressed.

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

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

Schema description coverage is 100% and the single 'path' parameter is documented in the schema as the project root directory. The description adds no parameter-level information, so the baseline 3 applies since the schema does the work.

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

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

The description states a specific verb (reset) plus resource (state) and enumerates the concrete actions performed: killing stuck re-index processes, removing stale locks, and cleaning state files. It is far more informative than the bare name, though it never names the closely related sibling clear_index, so an agent must infer the distinction from the action list.

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 explicit trigger conditions: 'Use this to fix issues like stuck indexing, lock conflicts, or corrupted state.' That is clear positive guidance for selecting the tool, but there are no exclusions or named alternatives (e.g. clear_index or reindex_changed_files) for when a plain re-index would suffice.

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 the return shape (relevant code chunks with similarity scores), which compensates for the absent output schema, but says nothing about permissions, rate limits, index-prerequisite behavior, or pagination limits.

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 purpose and followed by the return behavior. No filler or redundancy.

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 5-parameter search tool with a fully documented schema and no output schema, the description covers the core purpose and return values adequately. The main omission is the implicit prerequisite that the codebase has been indexed, which the agent must infer.

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

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

Schema description coverage is 100%: every parameter has a description with examples, enum values, ranges, and defaults (minScore default 0.7, maxResults default 10, language enum, regex pathPattern). The description adds no parameter meaning beyond the schema, so the baseline 3 applies.

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

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

The description states a specific verb and resource ('Search the indexed codebase semantically using natural language'), which clearly distinguishes this retrieval tool from the write/management siblings like index_codebase and clear_index. It stops short of naming an alternative sibling, but the purpose is unambiguous.

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

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

Usage is implied by 'semantically using natural language' but there is no explicit when-to-use guidance, no stated prerequisite that the codebase must already be indexed, and no routing to alternatives (e.g., grep or a file-read tool). The agent must infer the context.

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