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

With no annotations, the description carries full burden. It implies a read-only operation ('View') and lists data provided. It does not mention side effects, auth, or rate limits, but for a simple query tool, it is fairly transparent.

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 concise sentences plus a bullet list, front-loaded with key information. Every part adds value with no redundancy or fluff.

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 no output schema, the description specifies the metrics returned (call counts, success rates, latency, etc.), which is adequate for tool selection. It does not detail output format but covers expectations well.

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 all parameters already described. The description adds context for scope values and project identifier but does not significantly enhance understanding beyond the schema. Baseline score of 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?

The description explicitly states 'View API usage analytics per project or system-wide' and lists the specific metrics (call counts, success rates, latency, token usage, top tools, daily trends). It distinguishes between project and system scopes, making the purpose clear and differentiating from 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 details two scopes ('project' and 'system') with clear distinctions, guiding when to use each. However, it does not explicitly mention when not to use the tool or provide alternatives, though no direct siblings exist for analytics.

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 burden of disclosing behavior. It mentions storage location and retention pruning but does not clarify whether restore is destructive, authentication needs, or error conditions. This is adequate but lacks detail 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?

The description is concise at about 70 words, using a bullet list for actions. It is front-loaded with the main purpose. Could be slightly tighter but no significant 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 4 parameters, no output schema, and no annotations, the description covers the essential actions, storage path, and retention policy. It mentions that 'list' returns sizes and ages, which is helpful. It is reasonably complete for this tool's 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 coverage is 100% with all four parameters described. The description adds brief context for each action (e.g., 'Create a new backup now') but does not substantially extend beyond the schema meanings. Baseline 3 is appropriate since schema already documents parameters.

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 is for creating, listing, or restoring SQLite database backups. It then lists each action with a one-line explanation, making the purpose specific and distinct from unrelated sibling 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?

The description implicitly conveys that the tool is for backup operations, but it does not provide explicit guidance on when to use it versus alternatives, nor does it mention prerequisites or when not to use it. Given the sibling tools are unrelated, the lack of explicit guidelines is a minor gap.

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 full responsibility. It discloses the use of an OpenAI-compatible endpoint and live web grounding, but fails to mention any behavioral traits like rate limits, authorization requirements, or whether the operation is read-only. The description is insufficient for full 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 extremely concise at two sentences, with no filler. It front-loads the core purpose and immediately explains the technical mechanism.

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 output schema, the description should explain the return format or structure of the answer. It does not, leaving agents uncertain about what to expect. The description is adequate for a very simple tool but incomplete for full context.

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%, with both parameters (query and model) adequately described in the schema. The tool description adds minimal value beyond restating that it uses AI grounding, so the baseline score of 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?

The description clearly states the tool returns direct AI answers grounded in Brave Search, using an OpenAI-compatible endpoint. It distinguishes from sibling search tools like brave_web_search by emphasizing answer generation rather than raw results.

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 mentions it is 'best for concise answer generation with live web grounding,' which implies a specific use case. However, it does not explicitly state when not to use it or suggest alternatives, leaving some ambiguity about when to choose this tool over others.

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 provided, so the description carries full burden. It discloses automatic fallback to web search and lists returned information (names, ratings, hours). It lacks details on rate limits or authorization, but the key behavior is transparent.

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 concise paragraph with bullet points. It front-loads the purpose, then gives usage context, return info, and a fallback note. No unnecessary words, well-organized.

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, but description explains return details (business names, addresses, ratings, etc.) and fallback behavior. It misses error handling or pagination, but for a local search tool with two simple params, it is sufficiently 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% (both params described), baseline 3. The description adds meaning by specifying query examples ('pizza near Central Park') and default count behavior, plus clarifies what the return values include. This goes beyond 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 tool searches for local businesses and places using Brave's Local Search API. It distinguishes from siblings like brave_web_search by specifying physical locations and business entities, and notes a fallback to web search.

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 'Best for queries related to physical locations' and 'Use this when the query implies "near me" or mentions specific locations,' providing clear when-to-use guidance. It does not explicitly state when not to use, but the context is strong.

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?

Without annotations, description fully discloses behavior: performs search, runs JS in QuickJS sandbox, returns only script output. It explains the purpose of reducing context. It does not mention rate limits or authentication, but for a search tool this is acceptable. The sandbox and script execution are clearly described.

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 4 sentences, front-loaded with the main action, followed by usage guidance and script instructions. Every sentence provides value with no redundant information. Highly 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?

The tool combines search and code execution, and the description covers the main workflow and intent. It lacks details on error handling or script failure behavior, but it mentions the sandbox and output mechanism. Given the complexity and absence of output schema, it is fairly 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%, so baseline is 3. Description adds context for 'code' parameter by mentioning 'DATA' variable and console.log, and gives a query example. But overall it doesn't add significant meaning beyond the schema's own descriptions. The language parameter is explicitly noted as only supporting JavaScript.

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 that the tool performs a local search via Brave APIs and runs custom JS on the raw response, reducing context window usage. It distinguishes itself from siblings like 'brave_local_search' and 'brave_web_search_code_mode' by specifying 'local search' and 'code mode'.

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: 'local/business lookups when you only need specific fields from large local payloads.' It implies not to use when full payload is needed. Provides instructions on how to write the script (read DATA global, use console.log). However, it does not explicitly mention when not to use or alternatives beyond the use case.

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 provided, so description carries full burden. Mentions pagination, content filtering, freshness controls, and maximum results (20). However, does not explicitly state it is a read-only operation or discuss rate limits/auth. Adequate but not comprehensive.

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 concise sentences: first states purpose, second provides usage scenarios, third mentions capabilities. No fluff, 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?

Tool has 3 params and no output schema. Description covers purpose, usage, and constraints but lacks explanation of return value format or structure. Could be more complete for agent usage.

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%; baseline 3. Description adds slight value by reiterating max 20 results and offset usage, but no new parameter details beyond schema. Content filtering and freshness controls are mentioned but are not parameters.

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?

Clearly states 'Performs a web search using the Brave Search API' with specific verb+resource. Distinguishes from siblings like brave_answers and brave_local_search by stating 'ideal for general queries, news, articles, and online 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?

Provides explicit usage context: 'ideal for general queries, news, articles, and online content. Use this for broad information gathering, recent events, or when you need diverse web sources.' Lacks explicit when-not-to-use or alternatives, but context is clear.

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 adequately explains the sandbox execution, the DATA variable, and console.log output. It mentions 'secure QuickJS sandbox' but does not detail error behavior, rate limits, or authentication requirements.

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 very concise with two paragraphs: first explains functionality, second gives usage guidance and a code example. No superfluous content; every sentence adds value.

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 complexity of executing custom code, the description covers the core workflow and distinguishes from plain search. It lacks details on output format and error handling, but provides enough context for basic use.

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 baseline is 3. The description adds value by providing a concrete JavaScript example for the 'code' parameter and explaining the 'DATA' variable, which goes beyond the schema's basic 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?

The description clearly states it performs a web search and then executes custom JavaScript on the raw response, distinguishing it from plain search tools. It gives a specific use case ('broad information gathering... needing specific parts of the result') which differentiates it from siblings like brave_web_search.

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 (broad information gathering, recent events, needing specific parts) and implies when not to (for full results, use non-code version). However, it does not explicitly mention sibling names or provide contraindications.

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 provided, so description carries full burden. It details the secure sandbox, the DATA global variable, console.log output, and template usage. It does not explicitly state non-destructive behavior, but the processing nature is implied. Good but not exhaustive on side effects.

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 relatively long but well-structured. It front-loads the main purpose, then explains usage, then introduces new features. Every sentence adds information, though minor redundancy could be trimmed.

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 no output schema and 5 parameters, the description covers the usage pattern, parameter roles, and template options. Missing explicit output format or error behavior, but overall sufficient for an agent to use the tool correctly.

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

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

Schema coverage is 100% but description adds value: explains how 'code' interacts with 'data' via the DATA global, introduces templates as an alternative to 'code', and clarifies the role of 'source_tool' for logging. This goes beyond 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 tool's purpose: 'A universal code-mode transformer' that takes raw text/JSON from any MCP tool and runs custom JavaScript or uses templates for extraction. It differentiates from sibling tools like brave_local_search_code_mode by being universal, explicitly listing many source 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?

Explicit guidance: 'Use this as a second step after calling any tool that returns large payloads'. Provides clear when-to-use context, mentions templates for common cases, and alternatives (custom code vs template).

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 full burden for behavioral traits. It fails to disclose side effects (e.g., persistence of configuration, idempotency, rate limits, authentication requirements, or what happens on channel removal). The actions are listed but their behavioral implications are missing.

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 concise and well-structured, with a clear purpose sentence followed by a bulleted list of actions and events. It is front-loaded and each sentence contributes meaning 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?

Given the tool has 4 parameters, no output schema, and zero annotations, the description covers the actions and events adequately but lacks behavioral completeness. Information about return values, persistence, or error handling is absent, leaving gaps for a configuration 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 schema already documents all parameters. The description adds an overview of actions and events but does not enhance parameter meaning beyond what the schema provides. The description's extra context on events adds minor value, so score is baseline 3.

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 configures real-time notifications for memory events via webhook, Slack, or email. It lists specific actions and events, making its purpose unambiguous and distinct from sibling tools, none of which relate to notification configuration.

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 actions (status, add_channel, remove_channel, test) that an agent can use to decide which operation to perform. However, it does not explicitly state when to use this tool versus alternatives or include prerequisites, though the context (no sibling notifications tools) supports implicit usage.

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 provided, but description fully discloses conditions: never touches entries without compressed blobs, default/minimum thresholds, safety notes on accuracy and unaffected search tiers, and reclaim percentage.

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?

Well-structured with sections, bold key terms, and no superfluous sentences. Every sentence adds value, including safety and usage guidance.

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?

Despite no output schema, description explains expected behavior, preview with dry_run, and impact on storage and search. Covers all needed context for an agent to invoke correctly.

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

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

Schema covers all 3 parameters (100%), and description adds context: default values, minimum enforcement, dry_run behavior, and project filter omission meaning. Adds significant meaning beyond 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?

Description clearly states the tool purges high-precision float32 embedding vectors for entries with TurboQuant compressed blobs, specifying the exact resource and action. It distinguishes from siblings by focusing on post-backfill space reclamation.

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?

Explicitly states when to use: after TurboQuant backfill (session_backfill_embeddings). Also mentions dry_run for previewing impact, giving clear context for safe execution.

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 bears full responsibility. It explains the extraction methods (rule-based + optional LLM) and auto-save behavior, but lacks details on potential side effects, performance implications, or output format.

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 concise, with two paragraphs that efficiently convey the tool's action and use. It is front-loaded and every sentence adds value, though minor trimming is possible.

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 entity types and basic behavior, but lacks details about return values (no output schema) and does not mention edge cases or error handling. For a tool with 3 parameters, it is adequate but not thorough.

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 schema already documents all parameters. The description adds context about entity types and overall purpose, but doesn't significantly enhance parameter understanding 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 tool extracts named entities from raw text, listing specific entity types (PERSON, PROJECT, TECH, etc.). It effectively distinguishes itself from siblings, none of which offer similar functionality.

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 a clear use case: auto-enrich session context. While it doesn't explicitly mention when not to use or alternatives, the sibling tools are mostly unrelated, making the guidance sufficient.

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

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

No annotations exist, so the description carries the full burden. It names the model (Gemini-2.0-flash) and enumerates capabilities (extract findings, critique, etc.) but lacks details on output format, token limits, cost, or any limitations. This provides moderate transparency but leaves important behavioral aspects unspecified.

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 with no filler. It front-loads the main action and immediately conveys core purpose. Every sentence adds value, making it efficient for an AI agent to parse.

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?

Despite having no output schema, the description fails to explain what the tool returns (e.g., text response, structured data). It also omits prerequisites like paper length limits or document format requirements. For a tool with three parameters and no output schema, this omission leaves the agent without a complete picture of the tool's 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 100%, so the schema already describes all three parameters. The description does not add any extra meaning or context beyond what's in the schema (e.g., explaining enum values or how to use additionalContext). Per 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 performs in-depth analysis of research papers using Gemini-2.0-flash, listing specific capabilities like extracting key findings, critical evaluation, and summarization. It distinguishes itself from sibling tools, which are unrelated (e.g., backup, search, memory), making the purpose unique and specific.

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 the tool: 'Ideal for academic research, literature reviews, and deep understanding of scientific papers' and 'Best for long-form academic content that requires expert analysis.' However, it does not explicitly state when not to use it or mention alternatives, which is acceptable given no direct sibling competitor.

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 full burden. It explicitly states 'Read-only, no arguments' and clarifies that it reflects prism_infer delegation usage only. This provides sufficient behavioral disclosure beyond what annotations would supply.

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: the first lists the returned metrics, the second clarifies scope and exclusions. It is concise, front-loaded, and every sentence adds value with 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?

Although no output schema exists, the description enumerates the types of metrics returned (call count, split, token totals, per-model breakdown, latency). This provides reasonable completeness for a read-only metrics tool, though a brief note on response format would slightly improve 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?

The input schema has no parameters, so baseline is 4. The description does not need to add parameter meaning, and it appropriately explains that 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?

The description clearly states the tool returns inference metrics for the current session, listing specific metrics (call count, local vs cloud split, token totals, per-model breakdown, average latency). It distinguishes itself by explicitly noting what it does not cover (Claude's own token spend), 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 the tool (to get inference metrics) and what not to use it for (host model's token spend, directing to /cost instead). However, it does not explicitly mention when-not or alternative sibling tools, though the only related sibling is prism_infer, which is different.

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?

Discloses the main effect and a constraint (minimum 0), but does not mention error conditions, idempotency, or what happens when already at 0. No annotations to supplement.

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?

Extremely concise, two sentences with no filler. Front-loaded with action verb and key information.

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?

Simple tool but lacks information about return values or confirmation of action. No output schema, so agent may need to know if operation succeeded.

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 provides 100% coverage with clear description of the 'id' parameter. Tool description does not add extra 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?

Clearly states the action (downvote a memory entry), the effect (decrease importance), and a constraint (cannot go below 0). Distinguishes from sibling "knowledge_upvote" by name and opposite action.

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 explicit guidance on when to use this tool vs alternatives (e.g., knowledge_upvote or other memory tools). Context is implied but not stated.

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 fully discloses the destructive nature ('permanently deletes ledger entries'), the safety mechanism (confirm_all), and the behavior regarding handoff state (preserved unless clear_handoff is set). It also mentions dry_run for safe preview. This is thorough behavioral disclosure.

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

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

The description is well-structured with a vivid metaphor, bullet-pointed modes, and a clear warning. It front-loads the core purpose and each sentence adds value without redundancy. No unnecessary fluff.

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 purpose, modes, parameters, and side effects thoroughly. However, it does not specify the output format after deletion (e.g., how many entries were deleted or a confirmation message). Given the destructive nature, this minor gap prevents a perfect score.

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 description adds significant meaning beyond the 100% covered schema: it groups parameters into usage modes (by project, category, age, full reset) and explains the purpose of dry_run, confirm_all, and clear_handoff. This turns schema fields into actionable guidance.

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 'forget' (delete) accumulated knowledge entries, and defines four specific modes (project, category, age, full reset). It is specific about the verb and resource, and distinguishes itself from sibling knowledge tools that perform different operations (search, upvote, downvote, set retention).

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 explains when to use the tool ('remove outdated, incorrect, or irrelevant session entries') and details each forget mode with its use case. It lacks explicit when-not-to-use statements or references to alternative tools, but the context is clear enough for an agent to decide.

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 must convey behavioral traits. It discloses that content is chunked, Q&A pairs generated, and stored in the knowledge graph. However, it omits details on idempotency, overwrite behavior, authentication requirements, rate limits, or error handling, leaving gaps for an agent to infer.

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 four sentences, front-loaded with the core purpose, and contains no redundant or verbose phrasing. Every sentence adds value: purpose, inputs, process, and usage trigger phrases.

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 ingestion tool with no annotations or output schema, the description covers purpose, input types, processing steps, and when to use. It lacks output details and error conditions, but given the tool's moderate complexity, it provides sufficient 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 coverage is 100%, so the baseline is 3. The description adds context by mentioning input types (raw code, file paths, git URL) which map to parameters, but does not significantly enhance understanding of chunk_size or source_label beyond the schema's own 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 tool's purpose: ingesting source code or documentation into the knowledge graph for later retrieval by knowledge_search. It lists accepted input types (raw code, file paths, git URL) and explicitly distinguishes from sibling tools like knowledge_search by stating its role in populating the graph.

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 explicit usage cues: 'Use this when the user says learn this code, index my repo, or ingest this file.' It implies this tool is for ingestion only, not search or deletion, and contrasts with knowledge_search. However, it does not explicitly exclude other use cases or mention alternatives beyond implication.

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 explains that keywords are automatically extracted from ledger and handoff entries, and lists available categories. It does not contradict any annotations (none provided) and provides good insight into behavior beyond the schema.

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 concise and well-structured, with a main paragraph explaining purpose and a list of categories. Every sentence adds information 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?

Given the complexity (6 parameters, nested object) and no output schema, the description covers the tool's capabilities well. It explains search behavior, categories, and optional features, though detailed output format is not described.

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 adds value by explaining spreading activation in plain language and highlighting the trace option, which goes beyond the schema's technical 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 tool searches accumulated knowledge across sessions using keywords, category, or free text. It distinguishes itself from other search tools by emphasizing cross-session search and automatic knowledge base growth.

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 specifies using this to find related past work, decisions, and context from previous sessions. It does not explicitly mention when not to use or alternatives, but the context is clear enough for an agent to infer appropriate usage.

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 fully discloses the behavioral trait: entries are soft-deleted (archived) automatically on a schedule. It specifies the retention check frequency and the exclusion of rollup entries. Missing details include whether changes are immediately applied or reversible, but the main behavior is transparent.

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 concise and well-structured: a single sentence defining the tool, followed by bullet-point use cases and a note. Every sentence adds essential information, and the structure aids scanning. No unnecessary 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?

Given no output schema and no annotations, the description adequately covers the tool's purpose, usage, and behavior. It is complete for a simple two-parameter tool. Minor omissions: no mention of required permissions or impact on existing entries, but these are not critical for basic understanding.

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 baseline is 3. The description adds value by clarifying the effect of ttl_days=0 (disable auto-expiry) and giving a real-world example (ttl_days=90 for 3-month expiry). This goes beyond the schema's minimal descriptions and helps agents understand parameter semantics.

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: setting an automatic data retention policy (TTL) for a project's memory. It defines the action (set retention), resource (project memory), and behavior (soft-delete entries older than ttl_days). This distinguishes it from sibling tools like knowledge_forget (individual deletion) or memory_history (viewing history).

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 concrete use cases for ttl_days values (90 and 0) and explains when auto-expiry occurs (server startup and every 12 hours). It also notes that rollup entries are never expired. However, it does not explicitly mention contraindications or alternative tools for similar tasks, leaving some ambiguity about when not to use it.

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 full burden. It explains idempotency via sentinel markers, the three-step process, and dry_run behavior. Missing details on file creation or error handling, but still strong.

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?

Well-structured with front-loaded purpose, followed by how-it-works, requirements, and idempotency. Slightly verbose but efficient overall.

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?

Covers purpose, mechanism, requirements, and idempotency. Lacks edge cases like file creation or error handling, but is complete for a sync tool given no output schema.

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 thorough descriptions for all three parameters. The description adds no new semantic information beyond what the schema already provides.

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 verb 'Auto-sync' and resource 'graduated insights into IDE rules file'. It distinguishes itself from sibling tools as the only tool that syncs insights to static rules files.

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?

Provides clear context: bridges behavioral memory with IDE context, and lists a requirement (repo_path configured). However, it does not explicitly state when not to use it or mention alternatives, though alternatives may not exist.

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. It discloses that upvoting can lead to graduation at importance >=7 and that graduated insights always surface in behavioral warnings. This goes beyond a simple 'increase importance' but does not address reversibility or side effects.

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 very concise, consisting of two sentences. It is front-loaded with the main action and provides key behavioral context without any 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?

Given the tool's simplicity (one required param, no output schema, no annotations), the description adequately explains the purpose and outcome. It covers the graduation mechanism but could mention whether the tool returns any confirmation or error messages.

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 the single parameter 'id', and the description only repeats the schema description ('The UUID of the ledger entry to upvote'). No additional information about the parameter is provided, so it adds no extra meaning beyond what the schema already gives.

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 ('Upvote a memory entry') and its effect ('increase its importance (graduation)'). It also explains the consequence of reaching importance >=7, which distinguishes it from sibling tools like knowledge_downvote or knowledge_forget.

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 when to use (to increase importance of a memory entry) and mentions the graduation threshold, but does not explicitly state when not to use or mention alternative tools like knowledge_downvote. However, the context is clear enough.

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?

Given no annotations, the description discloses the synchronous nature, potential up-to-60-second delay, and the effect of reclaiming disk space. It does not mention potential locking or concurrency effects, but overall transparent.

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 well-structured with a clear lead sentence and follow-up details. It is moderately concise; every sentence adds value, though some minor redundancy could be trimmed.

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 purpose, usage, and performance, but does not mention the return value or output format (e.g., what the tool returns after vacuum or dry run). Since no output schema is provided, this gap reduces 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?

The schema already describes the dry_run parameter, but the description adds practical context: 'Use this to preview how large the database is before committing to a full vacuum.' This adds value 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 'Reclaim disk space after large purge operations by running VACUUM on the local SQLite database.' It specifies a specific verb and resource, and distinguishes itself from sibling tools like deep_storage_purge and backup_database.

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 advises calling after deep_storage_purge and explains why (SQLite doesn't reclaim pages automatically). It also notes remote backend behavior. However, it lacks explicit when-not-to-use or alternative 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?

No annotations are provided, so the description carries the full burden. It discloses that the tool overwrites the current handoff state and that no data is lost (version number moves forward). This adequately informs the agent of the behavior.

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 concise sentences: the first states the core action, the second provides an analogy and critical behavioral note. 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?

The description provides enough context for a revert tool, including the prerequisite and behavior. No output schema exists, but the return value is not essential for invocation. Slight gap: could mention the version increment explicitly, but it's implied by 'version number moves forward'.

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 already describes both parameters, and the description adds valuable context: target_version should be obtained from memory_history. This goes beyond the schema's description, improving clarity.

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 restores a project's memory to a past version, using an analogy to Git revert. It distinguishes itself from siblings like memory_history by explicitly referencing it as a prerequisite.

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 advises calling memory_history first to find the correct target_version, providing clear usage context. While it does not explicitly list when not to use it, the guidance is sufficient for an AI agent.

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?

Discloses that it shows version numbers, timestamps, and summaries. No annotations present, so description bears full burden. It describes a read-only operation but doesn't explicitly state non-destructive nature, which is a minor gap.

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 sentences, front-loaded with the main purpose. Every sentence adds value, no filler.

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 2 parameters and no output schema, the description is fairly complete: it explains what the tool does, when to use it, and what information is returned. Could explicitly note the read-only nature, but otherwise comprehensive.

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 covers 100% of parameters with descriptions. The tool description adds no additional meaning beyond the schema; it just reinforces the overall purpose. 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?

The description clearly states the tool's purpose: viewing the timeline of past memory states. It distinguishes from sibling tool memory_checkout by specifying this is for finding the correct version.

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?

Explicitly states when to use: BEFORE memory_checkout, and mentions the alternative tool. Provides clear context for usage.

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

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

No annotations are provided, so the description carries the full burden. It explains that each step returns instructions, code snippets, and progress, but does not disclose side effects, authentication needs, or behavior on error. For a wizard that likely creates data, persistence details are missing.

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 concise with a clear bullet list of actions, efficiently communicating the tool's purpose. It is front-loaded with the main function and avoids unnecessary details.

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 (no output schema, few parameters), the description covers basic operation but lacks information on error states, behavior when wizard has already been completed, or how to handle invalid action sequences.

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 baseline is 3. The description adds some value by listing actions and explaining return content, but largely echoes the schema enums. No additional detail on parameter format or constraints 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 it is an interactive setup wizard for new Prism users, listing specific actions and their purposes. It distinguishes itself from sibling tools, which are unrelated to onboarding.

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 implicitly suggests use for new users during setup but provides no explicit guidance on when to use this tool versus alternatives or when not to use it. Additional context about prerequisites or completion status would improve this dimension.

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?

Without annotations, the description fully discloses behavioral traits: tier selection based on RAM, thinking modes, verification with evidence, cloud fallback conditions. It covers safety, cost implications, and edge cases without contradiction.

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 concise (4-5 sentences) with no fluff. It front-loads the core purpose and tier logic, then covers fallback. Every sentence adds value.

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 complexity (13 parameters, no output schema), the description covers model selection, modes, verification, fallback, and parameter defaults. It provides sufficient context for an AI agent to invoke correctly.

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

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

Schema coverage is 100%, so baseline is 3. The description adds context beyond the schema by explaining the overall inference flow, tier selection, and mode-specific behaviors, enhancing understanding of parameter interactions.

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 runs inference on a local model to save cloud tokens, selects tiers based on RAM, and falls back to cloud when needed. It specifies use cases like code generation, summarisation, classification, and differentiates from siblings by being the local inference 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?

The description explains when to use the tool (for any synth task that would otherwise go to cloud) and when fallback occurs. However, it does not explicitly mention alternatives or scenarios where this tool should be avoided, leaving some ambiguity for edge cases.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the tool classifies intent, extracts keywords, executes search, and returns parsed intent, results, and optional LLM answer. It does not explicitly state that it is a read-only operation or disclose any side effects, but the read-only nature is implied by 'query.'

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 well-structured, starting with the main purpose, then examples, and finally the return value. It is not overly wordy, though the examples take space. Front-loading the core action is effective.

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 lack of annotations and output schema, the description sufficiently covers the tool's behavior, parameters, and usage. It explains what the tool does, how it works, and what it returns. No critical gaps for a query 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 coverage is 100%, with descriptions for all three parameters. The description adds value by providing example questions and explaining the 'synthesize' parameter's default behavior. It clarifies the optional 'project' scope, going beyond the schema's brief 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?

The description clearly states the tool's purpose: 'Query memories using natural language instead of structured tool syntax.' It specifies the verb (query), resource (memories), and method (natural language). This distinguishes it from sibling tools that likely use structured 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 provides examples of natural language questions and explains that the tool automatically classifies intent and executes search strategies. It implies usage for informal queries but lacks explicit guidance on when not to use it or alternatives. However, the context with sibling names like knowledge_search suggests structured 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?

No annotations provided, so the description must fully disclose behavior. It outlines the three-step process (scan, generate, patch) and mentions API cost considerations via the limit parameter. However, it does not disclose potential side effects like whether the operation is idempotent or if it logs changes, leaving some gaps.

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 well-structured with a brief header and numbered steps. It is concise, with no redundant sentences, though the bullet list could be more compact.

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 no output schema, the description should clarify the return value (e.g., count of repaired entries or success status). It does not, leaving an agent uncertain about what to expect after invocation.

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 adds minor context beyond the schema, explaining that the limit parameter 'keeps API costs predictable', but does not significantly enhance understanding of parameter semantics.

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 repairs ledger entries missing vector embeddings, with a specific verb 'repair' and resource 'ledger entries'. It distinguishes from siblings like session_backfill_links and session_compact_ledger.

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 explicit when-to-use context: 'Run this periodically or after known API outages'. It does not specify when not to use, but the guidance is clear and actionable for an agent.

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 provided, so description carries full burden. It discloses INSERT OR IGNORE behavior (safe to re-run), three strategies, and retroactive nature. However, it could mention potential performance impact on large projects or if it locks the database, but overall transparent for a low-risk operation.

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

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

Description is well-structured with sections: purpose, strategies, safety note, when to use. Every sentence adds value, no fluff. Concise but informative.

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 (one required param, no output schema), the description fully explains what the tool does, how it works (three strategies), safety (INSERT OR IGNORE), and when to use it. Contextually complete for an agent to decide and invoke.

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?

Only one parameter 'project' with full schema coverage. The description does not add new semantics beyond the schema; it merely restates the purpose. With high schema coverage, baseline score of 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?

The description clearly states the tool's verb 'retroactively create graph edges (memory links)' and specifies it operates on all existing entries in a project. It distinguishes from auto-linking on save and from sibling tools like session_synthesize_edges by mentioning 'backfill' and 'after upgrading to v6.0'.

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?

Explicit 'When to use' section: 'Run once after upgrading to v6.0 to populate the graph for existing memories. New entries are auto-linked on save (no manual action needed).' Provides clear context and when not to use.

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

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

No annotations are provided, so the description carries the full burden. While it mentions 'resolve' and lists return fields, it does not clarify whether the operation is read-only or has side effects, nor does it disclose authorization needs or rate limits. This is insufficient for a tool with no 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 three sentences long, front-loaded with the core action and output, and each sentence serves a purpose. No extraneous words or information.

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 tool has 7 parameters and no output schema. The description lists the return fields, which helps, but it lacks details on the routing algorithm, how thresholds interact, and whether the operation is safe. It is adequate but leaves gaps for an agent to fully understand the tool's 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 description coverage is 100%, so baseline is 3. The description adds context about 'policy-gated routing' and 'explainable', which indirectly relates to parameters like 'explain' and thresholds, but it does not add specific parameter-level meaning beyond what the schema already provides.

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: resolving an HDC compositional state into a nearest semantic concept with policy-gated routing. It specifies the return fields. However, it does not explicitly differentiate from sibling tools, so it's slightly below a perfect 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?

The description advises using this tool for 'explainable cognitive recall decisions in v6.5', which provides context. But it lacks when-not-to-use scenarios or alternative tools, resulting in only implied usage guidance.

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 fully discloses behavior: it uses Gemini for summarization, archives originals with soft-delete, and keeps recent entries intact. The step-by-step explanation and mention of dry_run preview add transparency. However, it does not cover failure modes or authorization requirements.

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 concise and well-structured: a single-sentence overview, a clear bulleted list of how it works, and a practical tip. Every sentence adds value with no 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?

Given the lack of output schema, the description does not specify the return format, which would be helpful for a summarization tool. However, it adequately covers behavior, parameters, and a preview option, making it fairly complete for selecting and invoking the 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 coverage is 100%, so the baseline is 3. The description does not elaborate on parameter details beyond mentioning dry_run in the usage note. The schema already describes each parameter, and the description adds minimal additional meaning.

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: 'auto-compact old session ledger entries by rolling them up into AI-generated summaries.' It uses specific verbs ('compact', 'roll up') and identifies the resource ('old session ledger entries'), distinguishing it from siblings like session_save_ledger or session_backfill_links.

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 a clear usage hint: 'Use dry_run=true to preview without executing,' which guides the agent on when to use preview mode. While it does not explicitly state when not to use the tool or compare to alternatives, the steps and context imply it is for maintenance to prevent ledger growth.

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 provided, so description carries full burden. It explains the algorithm and return values but does not disclose side effects, permissions, rate limits, or error conditions. It implies a read operation but does not explicitly confirm safety.

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?

Well-structured with clear sections: purpose, triggers, pre-warning, returns. Each sentence adds value. Slightly long but 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?

Given no output schema and no annotations, the description covers detection logic, triggers, return fields, parameters, and usage. Lacks details on error handling and performance, but sufficient for selection among siblings.

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 detailed property descriptions. The tool description adds extra context (e.g., specificity recommendation for goal, domain-specific signals), improving understanding 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 tool detects semantic drift from the original goal using specific methods. It distinguishes itself from sibling tool 'session_cognitive_route' by explicitly saying to call this tool instead for goal-alignment drift detection.

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 explicit triggers (goal-drift, context-collapse) and pre-warning (quality-degrading). It gives direct usage guidance: 'Use alongside GATE 5... call this tool instead of session_cognitive_route for goal-alignment drift detection.' This tells when and when not to use it.

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 fully discloses what is exported, including redaction of API keys, file format details, and a prerequisite warning about output directory existence and writability. This provides comprehensive behavioral insight.

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 well-structured with sections and lists, but slightly verbose. All sentences add value, but some redundancy could be trimmed.

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 no output schema, the description thoroughly covers what is exported, formats, and operational constraints (directory must exist, auto-generated filenames). It is complete for the tool's 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 coverage is 100%, and the description enriches each parameter: it explains format variations in detail, clarifies default and project omission behavior, and gives an absolute path example for output_dir.

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 specific verb 'Export' and resource 'memory' with clear scope 'of a project's memory to a local file'. It uniquely identifies the tool's purpose among siblings like session_load_context or session_save_handoff.

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 ties usage to GDPR Article 20 and 'local-first' portability, providing clear context. It does not explicitly state when to avoid using it or name alternative tools, but the context is sufficient for decision-making.

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 fully discloses both modes: soft delete tombstones entries (reversible, excluded from search), hard delete removes permanently (irreversible). It also explains audit trail implications and GDPR context.

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 concise (6 sentences), front-loaded with the core action, uses markdown for emphasis, and every sentence adds value 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?

Given the 3 parameters and no output schema, the description comprehensively covers purpose, modes, usage guidelines, and behavioral transparency. An agent has all needed information to select and invoke this tool correctly.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds no extra semantic detail beyond the schema for parameters like reason, memory_id, and hard_delete.

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 forgets (deletes) a specific memory entry by ID, and distinguishes between soft and hard delete modes. This differentiates it from sibling tools like session_search_memory or session_save_ledger.

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 recommends soft delete for most cases and specifies hard delete only for GDPR Article 17 compliance. This provides clear when-to-use and when-not-to-use guidance.

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 full burden. It discloses that integrity checks are run and that auto_fix=true will mutate state (backfill embeddings, remove orphans). It does not detail rollback or impact on unrelated data, but covers the main behavioral traits.

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 concise and well-structured: a summary sentence, a bulleted list of checks, and a final line about auto_fix. Every sentence adds information 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 diagnostic tool with one optional parameter, the description covers the checks and the effect of auto_fix. However, it lacks information about output (e.g., report or success message) and could mention if the checks are read-only by default. Overall sufficient given no output schema.

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

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

Schema coverage is 100% and schema describes auto_fix as boolean with default false. The description adds value by specifying what 'repair' entails (backfill embeddings, remove orphaned handoffs), which goes beyond the schema's text.

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 it 'Run integrity checks on the agent's memory' and lists four specific checks (missing embeddings, duplicate entries, orphaned handoffs, stale rollups). This distinguishes it from sibling tools like 'maintenance_vacuum' or 'session_compact_ledger' by focusing on health diagnosis.

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 explains what checks are performed and when auto_fix=true can be used to repair issues. However, it does not explicitly state when not to use this tool or suggest alternatives among siblings, leaving some ambiguity.

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 must bear the full burden. It discloses three context loading levels with token costs and mentions progressive loading. However, it does not detail permissions, side effects, or whether it modifies state (likely not, as it's loading).

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 concise, front-loaded with the main purpose, and uses a bulleted list for the three levels. Every sentence adds value without 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's complexity (progressive loading, multiple parameters, enum), the description covers the main use case and token budgets. It lacks an output schema but mentions truncation behavior, making it sufficient for an agent to invoke correctly.

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

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

Schema coverage is 100%, so baseline is 3. The description adds some value by explaining the three levels in narrative form and recommending 'standard', but the schema already describes each parameter adequately. The description does not significantly supplement parameter meaning beyond what the schema provides.

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 loads session context for a project using progressive context loading. It specifies it should be used at the start of a new session to recover previous work state, distinguishing it from siblings like session_save_ledger or session_compact_ledger.

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 to use this at the START of a new session and recommends the 'standard' level. It provides clear context but does not explicitly state when not to use it or mention alternatives among the many sibling session 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?

No annotations are provided, so the description must fully disclose behavior. It explains the nature of events but omits details on side effects, authentication needs, idempotency, or error handling, which are important 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?

Very concise with a clear structure: a title, a contrast sentence, and a succinct bullet list of event types. No superfluous content.

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 8 parameters (5 required) and no output schema, the description adequately explains purpose and differentiation but fails to mention what the tool returns or any post-conditions, leaving some gaps.

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, baseline is 3. The description adds value by elaborating on event types and their meaning, supplementing 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 tool records typed experience events and explicitly distinguishes it from the sibling tool 'session_save_ledger' by contrasting flat logs with structured behavioral 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?

It provides clear context on when to use this tool (for structured behavioral data and pattern detection) and contrasts it with a specific sibling, implying when not to use it. It lacks explicit exclusion criteria for other 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?

With no annotations, the description fully discloses behavior: upsert semantics, CRDT merge, OCC, version control, disable_merge, and conversation_id verification. It clearly explains what happens on version conflict and the concurrency control mechanisms.

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 well-structured with sections for CRDT and OCC, and the main purpose is front-loaded. It is slightly verbose but every sentence adds value, making it appropriately concise for the complexity.

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 9 parameters and no output schema, the description covers the behavioral and parameter usage thoroughly. However, it does not describe the return value (e.g., success or version number), which slightly limits completeness for an upsert 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 baseline is 3. The description adds value by explaining the role auto-resolution, the necessity of expected_version when a version number is known, and the effect of disable_merge. This goes beyond the schema's basic 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 'Upsert the latest project handoff state for the next session to consume on boot,' specifying the verb, resource, and context. It distinguishes from sibling tools like session_load_context by focusing on saving 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?

It explicitly mentions when to use (after a session to save context for next boot) and provides conditions for expected_version. However, it does not explicitly mention when not to use or list alternative tools, which would raise it to a 5.

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

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

No annotations are provided, so the description carries the full burden for behavioral disclosure. It explains that the image is copied into Prism's media vault, indexed in handoff metadata, and becomes visible on the next session_load_context. This sufficiently discloses the tool's effects and downstream behavior.

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 sentences and no fluff. The purpose is front-loaded in the first sentence. Every sentence provides unique, actionable information without repetition.

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; the description explains the post-save lifecycle (media vault storage, indexing, visibility on next context load). Given the tool's simplicity and the presence of a sibling for viewing (session_view_image), the description is fully 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%, so the description adds value beyond structural details. For the description parameter, it clarifies purpose ('What does this image show? Used for indexing'). For file_path, it repeats 'absolute or relative path' from the schema but reinforces the accepted formats. This adds helpful context.

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 opens with a clear verb+resource ('Save a local image file into the project's permanent visual memory') and enumerates specific use cases (UI states, diagrams, architecture graphs, bug screenshots). This differentiates it from siblings like session_save_experience or session_save_handoff.

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 the tool ('Use this to remember UI states, diagrams...'). It does not explicitly state alternatives or exclusions, but the sibling list includes session_view_image (viewing) and session_save_experience (saving experiences), so usage context is clear.

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 fully discloses critical behaviors: immutability, append-only nature, inability to update/delete, and permanent audit trail. This is exemplary transparency 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?

The description is three concise sentences, each adding value: purpose, usage context, and behavioral constraints. No fluff 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?

Given no output schema, the description sufficiently covers return behavior implicitly. It explains the ledger's permanence and usage timing, but could optionally mention indexing or confirmation. Overall, very complete for a save 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?

Input schema has 100% coverage with clear descriptions for all 7 parameters. The description does not add additional parameter semantics beyond what the schema already provides, meeting the baseline.

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 saves an immutable session log entry to the session ledger, differentiating it from sibling tools like session_save_experience or session_compact_ledger. It uses specific terms like 'session ledger' and 'audit trail', making the purpose unmistakable.

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 advises use 'at the END of each work session', providing clear context. It does not list alternatives or when not to use, but the timing instruction is strong guidance.

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 provided, but the description discloses the semantic search mechanism, vector embedding usage, and optional trace feature. It does not explicitly state read-only behavior, but that is implied. Overall, it provides good behavioral context beyond the bare minimum.

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 purpose and mechanism, followed by prerequisites and usage guidance. Every sentence adds value with no redundant or unnecessary content.

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 explains purpose, mechanism, and usage well but does not describe the return format or structure of results. Given that there is no output schema, a brief note on what the tool returns would improve 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 coverage is 100%, but the description adds valuable context for parameters like activation (ACT-R spreading activation) and context_boost (biasing toward contextual relevance), enhancing understanding beyond the schema definitions.

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?

Clearly states the tool searches session history semantically using vector embeddings, distinguishing from keyword-based search. The verb 'Search' and resource 'session history' are specific and 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?

Explicitly tells when to use this tool vs the sibling `knowledge_search` (keyword-based) — use when keyword search fails or query phrasing differs. Also mentions requirement of pgvector extension, providing clear guidance.

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