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

The description adds behavioral context beyond the annotations: it specifies exactly what is deleted (ChromaDB collection, .codebaxing/ data) and what is preserved (ignore.json). The annotations already declare destructiveHint=true and idempotentHint=true, and the description is consistent with those, adding useful detail about the scope of destruction.

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 three sentences, front-loaded with the core purpose, followed by specific details, then a use case. Every sentence adds value, and there is no unnecessary information. It is highly concise 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?

For a simple tool with one parameter and no output schema, the description covers the main aspects: what it does, what it deletes/preserves, and when to use it. It does not mention the return value, but for a destructive cleanup operation, a return value is less critical. Slight gap in not describing the response format, but overall sufficient.

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% coverage for the single parameter 'path' with a clear description. The tool description does not add any additional parameter semantics beyond what the schema already provides. According to the guidelines, baseline 3 is appropriate when schema coverage is high.

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's purpose as cleaning all indexed data for a codebase, specifying what gets deleted (ChromaDB collection, .codebaxing/ data) and what is preserved (user config). This is a specific verb+resource combination that distinguishes it from sibling tools like 'index' (which creates indexes) and 'search' (which queries).

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 says when to use the tool: 'Use this to fix corrupted indexes or start fresh.' This provides clear context for appropriate usage. However, it does not explicitly state when not to use it or list alternatives, though the context strongly implies it is for cleanup scenarios.

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 declares 'DESTRUCTIVE' and lists the deletion criteria, which aligns with the annotations (destructiveHint=true, readOnlyHint=false, idempotentHint=true). It adds value by explaining what gets deleted (memories matching criteria) and provides examples of the older_than format. The idempotentHint is slightly contradicted by the fact that repeated calls with different criteria could delete different sets, but the description's criteria listing partially mitigates this.

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

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

The description is two sentences: a clear purpose statement and a concise list of criteria. Every word is meaningful, and the critical warning 'DESTRUCTIVE' is front-loaded. No 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?

Given the tool has 5 parameters, all documented in the schema, and no output schema, the description covers the essential delete-by criteria and the destructive nature. It could be improved by noting that all parameters are optional and might combine (e.g., AND logic), but the completeness is high for a deletion 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 the baseline is 3. The description adds value by listing the delete-by options and providing the 'older_than' format examples (1d, 7d, 30d, 1y), which the schema also describes. It does not add new meaning 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?

The description clearly states the verb 'remove' and the resource 'memories', and lists the specific criteria for deletion. The 'DESTRUCTIVE' prefix and the list of delete-by options distinguish it from sibling tools like 'recall' (retrieval) and 'search' (non-destructive filtering).

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 lists the criteria for deletion (memory_id, memory_type, tags, older_than), which guides when to use each parameter. It lacks explicit guidance on when not to use this tool (e.g., preferring 'clean' for cleanup), but the list of criteria and the destructive warning provide clear usage 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?

Annotations provide idempotentHint=true, readOnlyHint=false, destructiveHint=false. The description adds behavioral context: it creates a .codebaxing/ folder, describes mode-specific behaviors (incremental vs full vs load-only), and implies file system modifications. No contradiction with 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 extremely concise: two short sentences plus a three-line bullet list for modes. Every sentence adds distinct value (purpose, required status, mode variants, side effect). Front-loaded with the core purpose.

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 4 parameters (all documented in schema), no output schema, and moderate complexity (tool changes filesystem), the description covers the critical aspects: purpose, required-first-step context, mode options, and a key side effect (folder creation). It does not describe return values or error conditions, but for a setup/indexing tool this is acceptable. A perfect score would require mention of typical output or behavior on failure.

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% with 4 parameters. The description expands on the 'mode' parameter by explaining each enum value's purpose, which adds value beyond the schema's terse 'Indexing mode'. However, it does not add any new information for path, embedding_model, or file_extensions (their schema descriptions already clear). Baseline 3 is appropriate.

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?

Description clearly states 'Index a codebase for semantic search' and identifies it as 'REQUIRED FIRST STEP', which strongly distinguishes it from sibling tools like search, stats, and clean. The verb 'index' and resource 'codebase' are precise.

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 says 'REQUIRED FIRST STEP', indicating it must be run before dependent operations. It details three modes (auto, full, load-only) and when each is appropriate. However, it does not explicitly state when NOT to use the tool or list alternatives, though context implies alternatives are the other 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 declare readOnlyHint=true and idempotentHint=true, so the description does not need to detail safety. It adds value by specifying the output is a list of 'languages and extensions,' which is beyond what annotations provide. No contradictions are 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?

The description is a single, clear sentence that conveys exactly what the tool does with no unnecessary words. It is perfectly concise and 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?

Given the tool has zero parameters, no output schema, and simple behavior (listing static data), the description fully specifies the tool's purpose. No additional information is needed for an agent to use it correctly.

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

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

The input schema has zero parameters and 100% coverage, so the description's job is minimal. It adds clarity by stating what the tool returns (languages and file extensions), which is helpful beyond the empty 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 uses the verb 'list' clearly indicating the action, and specifies the resource as 'supported programming languages and file extensions.' This uniquely identifies what the tool does and distinguishes it from siblings like 'search' or 'index.'

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

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

The description implies the tool is for retrieving a static list of supported languages and extensions, which is clear context. However, it does not explicitly state when not to use it or mention alternatives, though given the simplicity and absence of parameters, this is a minor omission.

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 provide readOnlyHint=true, idempotentHint=true, and no destructive hint, so the tool is clearly safe and non-mutating. The description adds is scoped to 'current project', clarifying it doesn't access global memory stats. No contradiction with annotations—the description aligns with the read-only, idempotent nature. Score is high because annotations do most of the work and the description complements without contradicting.

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 9-word sentence delivers the core purpose, which is front-loaded and concise. No extraneous information. However, it could be slightly more structured by hinting at return format or usage conditions, but given the tool's simplicity, it earns a 4 for efficiency.

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 has 1 optional parameter, no output schema, and good annotations, the description is fairly complete for a simple stats tool. It specifies scope (current project) and purpose (statistics), but lacks details on what statistics are returned (e.g., counts, sizes, timestamps) or how the optional path parameter affects results. With 9 sibling tools including a `stats` tool, more completeness would help disambiguate.

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 the single `path` parameter is fully documented in the schema. The description doesn't add semantics beyond what the schema provides, but with full coverage, baseline 3 applies. Score raised to 4 because the description implies parameter optionality (no required parameters listed) and integrates it into the 'current project' goal, slightly contextualizing its use.

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 'Get statistics about stored memories for the current project' uses a specific verb ('Get', 'statistics') and resource ('stored memories') with a context qualifier ('current project'), making the purpose clear. It distinguishes from siblings like `search` (finding specific memories) and `index` (indexing operations), though it doesn't explicitly differentiate from the sibling `stats`, which could be a similar statistics tool.

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 tool guidance is provided. The description implies it's for retrieving memory statistics, but there's no context on when to prefer this over siblings like `search` or `remember`. The sibling `stats` could be redundant, but no differentiation is offered.

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 mark the tool as readOnlyHint=true and idempotentHint=true, so the description adds only the phrase 'semantic search' to indicate the retrieval method. This is a minor behavioral clarification beyond the annotations, but it does not disclose other aspects like result ordering or pagination.

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 extremely concise: two sentences (19 words) that front-load the primary action and then list filters. No wasted text; 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?

Given the tool's simplicity (6 parameters, no output schema, clear annotations), the description covers the core purpose and key filter options. However, it omits explanation of the 'path' parameter (auto-loading) and the structure of returned results, which would be helpful for complete agent comprehension.

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%, earning a baseline of 3. The description adds value by specifying valid values for the 'time_range' parameter ('today, week, month, all'), which the schema only describes as 'Time filter'. This extra detail aids the agent in constructing correct queries.

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 'Retrieve memories using semantic search,' which clearly identifies the verb and resource. However, it does not differentiate from the sibling tool 'search,' which could cause confusion for an agent deciding between them.

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 is provided on when to use this tool versus its siblings (e.g., 'search', 'remember', 'index'). There is no mention of context, prerequisites, or exclusions, leaving the agent without direction for appropriate selection.

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 all false (no readOnly, no idempotent, etc.), so the description must document side effects. It correctly implies persistence (creating a stored memory) but does not disclose limits (e.g., max memory size, if overwrites occur for same tags). With zero annotation support, it could be more explicit about what gets created or modified.

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

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

The description is two short paragraphs: a one-line purpose statement followed by a line each for memory types and TTL options. It is front-loaded and efficient. No unnecessary words, but the bullet-like structure in prose could be tighter.

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

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

The description covers core function (store), memory types, and TTL, which suffices for a simple storage tool. However, with no output schema and 5 parameters, it misses retrieval context (e.g., how to later fetch by type/tag) and any limits (e.g., character max for content). This leaves an agent partially informed.

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 the baseline is 3. The description enumerates memory types and TTL options, duplicating the schema's enum values but not adding deeper meaning (e.g., what 'doc' vs 'note' means semantically). It provides no examples or format rules beyond what the schema declares.

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 'Store a memory for later retrieval' with a clear verb-resource pair. It distinguishes from siblings like 'recall' (reading memories) and 'forget' (deleting) by focusing on write operations. However, it could more explicitly contrast with siblings.

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

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

The description provides memory types and TTL options, which imply scenarios (e.g., decisions need month TTL). However, it does not explicitly say when to use this tool vs 'index' or when not to. It lacks guidance on prerequisites or alternatives.

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, so the agent knows this is a safe, read-only operation. The description adds value by describing the return format ('ranked code chunks with file paths and line numbers'), but does not disclose additional behavioral details such as whether results are transient or depend on an index. With annotations present, this level of detail is adequate.

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 extremely concise: two sentences and two examples. The first sentence front-loads purpose and output format. Examples are compact and directly demonstrate typical usage. There is no redundancy or wasted text.

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

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

Given the tool's moderate complexity (5 parameters, no output schema), the description covers the core functionality and output format. However, it omits important context such as whether an index must be built first (sibling 'index' suggests a dependency), or how the ranking works. The presence of good annotations partly compensates, but a mention of prerequisites would make it complete.

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

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

Schema coverage is 100% for all 5 parameters, providing baseline descriptions. The description's examples illustrate usage of 'question', 'language', and 'symbol_type', but these do not add meaningful semantics beyond what the schema already conveys. The description does not clarify how 'semantic search' leverages these parameters or what values are valid for 'language' or 'symbol_type'.

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 'Semantic search for code' and specifies that it returns ranked code chunks with file paths and line numbers. This is a specific verb+resource combination and easily distinguishes from sibling tools like index, stats, or memory 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 does not provide any guidance on when to use this tool versus alternatives. For example, it does not mention prerequisites like needing to run 'index' first, nor does it specify when a different search approach (like grep or exact match) would be more appropriate. The user must infer usage from the examples 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?

Annotations already provide readOnlyHint=true, idempotentHint=true, and openWorldHint=false, which cover safety and behavior. The description adds no additional behavioral traits beyond restating the purpose, so it meets the baseline but does not exceed.

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 a single, well-structured sentence with no fluff. Every word adds value, making it highly concise.

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

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

The description is too vague given no output schema. It does not explain what statistics are returned (e.g., file count, size, language breakdown), leaving the agent guessing about the tool's output.

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 only parameter 'path' is fully described in the input schema (100% coverage). The description adds no extra meaning beyond what the schema already provides, so 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 clearly states the action ('Get statistics') and the resource ('the currently loaded codebase index'). It distinguishes from siblings like 'memory-stats' by specifying 'codebase index', though it doesn't explicitly contrast them.

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 tool vs. alternatives (e.g., 'memory-stats', 'search'). The description only states what it does, not the context or exclusions.

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