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

The description adds valuable behavioral context beyond what annotations provide: it explains the hybrid nature of the search (semantic + exact matching), mentions it handles typos/variations, and describes what gets returned (code snippets with file locations and line numbers). Annotations cover safety (readOnly, non-destructive, idempotent) but the description adds operational details.

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 perfectly front-loaded and concise: the first sentence states the core function, the second provides usage context with examples, and the third describes the return format. Every sentence earns its place with no wasted words.

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

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

For a search tool with good annotations (readOnly, idempotent) and full schema coverage, the description provides solid context about behavior and output. The main gap is the lack of output schema, but the description does explain what gets returned. It could be more complete by mentioning limitations or performance characteristics.

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?

With 100% schema description coverage, the input schema already fully documents both parameters. The description doesn't add meaningful parameter semantics beyond what's in the schema - it mentions natural language queries as an example, but the schema already states 'can be natural language'. Baseline 3 is appropriate when 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?

The description clearly states the tool 'performs intelligent hybrid code search combining semantic understanding with exact text matching' - a specific verb (performs search) and resource (code). It distinguishes from siblings by emphasizing semantic understanding and handling typos/variations, which none of the sibling tool names suggest.

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 provides clear context about when to use this tool ('ideal for finding code by meaning... even with typos or variations'), giving examples like 'authentication logic' and 'database queries'. However, it doesn't explicitly state when NOT to use it or mention specific alternatives among the sibling tools.

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 already indicate this is a non-destructive, idempotent operation (destructiveHint: false, idempotentHint: true), but the description adds valuable context beyond that: it specifies that this is a 'full reindex' that 'scans all files' and 'updates the embeddings cache', which clarifies the scope and impact. It doesn't mention performance implications or rate limits, but adds meaningful behavioral details.

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 front-loaded with the core action in the first sentence, followed by a brief explanation and usage context. Every sentence earns its place by providing essential information without redundancy, making it efficient and well-structured.

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 the tool's complexity (a reindex operation with one parameter) and rich annotations (covering safety and idempotency), the description is mostly complete. It explains the purpose and usage context well, but lacks details on output (no output schema) or potential side effects like performance impact. However, with annotations providing key behavioral hints, it's sufficient for most use cases.

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 input schema has 100% description coverage, with the 'force' parameter fully documented in the schema itself. The description does not add any additional meaning or details about parameters beyond what the schema provides, so it meets the baseline of 3 for high schema coverage without extra value.

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 clearly states the specific action ('manually trigger a full reindex of the codebase') and the resource ('codebase'), distinguishing it from siblings like 'c_clear_cache' (which clears cache) or 'a_semantic_search' (which searches). It explains what the reindex does ('scan all files and update the embeddings cache'), making the purpose explicit and distinct.

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

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

The description provides clear context on when to use this tool ('useful after large code changes or if the index seems out of date'), which helps guide usage. However, it does not explicitly state when not to use it or name alternatives (e.g., compared to 'd_check_last_version' for checking index status), so it falls short of a perfect score.

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?

The description adds valuable behavioral context beyond annotations: it explains that clearing the cache forces a reindex on next operation, which is a significant side effect. Annotations already indicate destructiveHint=true and idempotentHint=true, but the description elaborates on the practical impact, enhancing transparency without contradicting 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 front-loaded with the core action in the first sentence, followed by a concise explanation of use cases. Every sentence earns its place by adding critical information without redundancy, making it highly efficient and well-structured.

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 the tool's complexity (destructive operation with no parameters) and rich annotations, the description is nearly complete. It explains what the tool does, when to use it, and the behavioral outcome. The lack of an output schema is mitigated by the clear action description, though minor details like error handling or confirmation prompts aren't covered.

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?

With 0 parameters and 100% schema description coverage, the baseline is high. The description doesn't need to explain parameters, but it implicitly confirms there are no required inputs by focusing on the action and consequences, which aligns perfectly with the empty input 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?

The description clearly states the specific action ('Clears the embeddings cache') and the resource affected ('embeddings cache'), distinguishing it from sibling tools like search or indexing operations. It goes beyond the title by explaining the consequence ('forcing a complete reindex on next search or manual index operation'), making the purpose 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?

The description explicitly states when to use this tool: 'Useful when encountering cache corruption or after major codebase changes.' This provides clear context for application, helping the agent decide when to invoke it versus alternatives like checking status or performing searches without clearing cache.

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 already declare readOnlyHint=true and idempotentHint=true, indicating a safe, repeatable read operation. The description adds valuable context beyond annotations by specifying the return type ('Returns the version string'), listing supported ecosystems, and mentioning auto-detection capabilities. No contradictions with annotations 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?

The description is efficiently structured in two sentences: the first states the purpose and scope, the second explains the return value and benefit. The extensive ecosystem list is necessary for completeness, and every sentence earns its place without 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 read-only, idempotent tool with full schema coverage but no output schema, the description is largely complete. It explains the purpose, scope, return value, and usage context. A minor gap exists in not detailing error cases or response formats, but overall it provides sufficient context given the annotations and schema richness.

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?

With 100% schema description coverage, the input schema fully documents both parameters. The description adds marginal value by mentioning ecosystem prefixes and auto-detection, but does not provide additional syntax or format details beyond what the schema already specifies. Baseline 3 is appropriate when 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?

The description clearly states the specific action ('Get the latest version') and resource ('library/package from its official registry'), with explicit scope ('Supported ecosystems...'). It distinguishes this tool from siblings like 'a_semantic_search' or 'b_index_codebase' by focusing on dependency version checking rather than search or codebase operations.

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 provides clear context for when to use this tool ('to help you avoid using outdated dependencies'), but does not explicitly state when not to use it or name alternatives. It implies usage for dependency management scenarios, though no exclusions or comparisons to sibling tools are mentioned.

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 of behavioral disclosure. It mentions that the tool 'Creates cache folder automatically' and 'optionally re-indexes', which are important behavioral traits beyond just changing a path. However, it doesn't address potential side effects like what happens to existing workspace state, whether this requires specific permissions, or if there are any rate limits or constraints on workspace switching.

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 efficiently structured in two sentences that each earn their place: the first states the core purpose and usage context, the second adds important behavioral details about cache creation and re-indexing. There's no wasted verbiage and information is front-loaded appropriately.

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 provides adequate coverage of the core functionality but lacks completeness. It doesn't describe what the tool returns (success/failure indicators, error conditions), doesn't explain what 're-indexing' entails in practical terms, and doesn't address potential failure modes or constraints on the workspace path parameter beyond it being 'absolute'.

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?

With 100% schema description coverage, the schema already documents all three parameters thoroughly. The description adds minimal value beyond the schema - it mentions 'optionally re-indexes' which relates to the 'reindex' parameter, but doesn't provide additional semantic context about parameter interactions or usage patterns beyond what's in the schema descriptions.

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 clearly states the specific action ('Change the project workspace path at runtime') and resource ('workspace'), distinguishing it from siblings like 'clear_cache' or 'get_status'. It explicitly mentions creating cache folders and re-indexing, which differentiates it from simple path-setting operations.

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 provides clear context for when to use this tool ('when you detect the current workspace is incorrect or you need to switch to a different project directory'), but doesn't explicitly state when NOT to use it or name specific alternatives among the sibling tools (e.g., when to use 'clear_cache' separately vs. using the clearCache parameter here).

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 of behavioral disclosure. It effectively describes the tool as a read-only status check (implied by 'Get' and 'Returns'), which is appropriate for a zero-parameter tool. However, it lacks details on potential side effects, error conditions, or response format specifics that would enhance 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 description is efficiently structured in two sentences: the first states the action and detailed return values, the second provides usage context. Every phrase adds value without repetition or fluff, making it easy to parse and understand quickly.

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

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

For a zero-parameter tool with no annotations or output schema, the description is reasonably complete—it explains what the tool does and what information it returns. However, it could be enhanced with details on output format or error handling to fully compensate for the lack of structured metadata.

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 with 100% schema description coverage, so no parameter documentation is needed. The description appropriately focuses on the tool's purpose and output without redundant parameter details, meeting the baseline expectation for parameterless tools.

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 clearly states the specific action ('Get comprehensive status information') and resource ('Smart Coding MCP server'), distinguishing it from sibling tools like indexing or cache clearing. It explicitly lists the types of information returned (version, workspace path, model configuration, indexing status, cache information), making the purpose 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?

The description provides clear context for when to use this tool ('Useful for understanding the current state of the semantic search system'), which implicitly differentiates it from siblings focused on actions like search, indexing, or configuration changes. However, it does not explicitly state when not to use it or name specific alternatives.

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