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

With no annotations provided, the description carries full burden and does well by disclosing key behavioral traits: it's a manual adjustment tool (not automatic), allows overriding decay, and includes confidence ranges with semantic meaning. However, it doesn't mention potential side effects (e.g., if this affects other systems) or error conditions.

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

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

The description is efficiently structured with clear sections (purpose, use cases, examples, confidence ranges), each sentence adds value, and it's front-loaded with the core purpose. No redundant or verbose language.

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

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

For a mutation tool with no annotations and no output schema, the description provides good context: clear purpose, usage guidelines, parameter semantics, and behavioral context. It could be more complete by mentioning what happens after adjustment (e.g., if it triggers notifications) or error cases, but it covers most essential aspects 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 description coverage is 100%, so the baseline is 3. The description adds significant value beyond the schema by providing concrete examples with realistic parameter values and explaining the semantic meaning of confidence ranges (0.9-1.0 = 'High confidence', etc.), which helps the agent understand appropriate values.

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 with specific verbs ('manually adjust confidence of a relationship') and distinguishes it from siblings like 'apply_memento_confidence_decay' (automatic) and 'boost_memento_confidence' (likely one-directional). It explicitly defines the action on a specific resource type (relationship confidence).

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 'Use for' scenarios with three specific cases (correcting scores, setting custom confidence, overriding decay), giving clear guidance on when to invoke this tool. It implicitly distinguishes from alternatives like automatic decay tools by mentioning 'overriding automatic decay.'

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes key behavioral traits: the decay rules (e.g., no decay for critical memories, reduced decay for high importance), the decay formula, minimum confidence threshold, and return values. It does not mention side effects like performance impact or permissions required, but covers core behavior well for a maintenance 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 well-structured with clear sections (purpose, usage, rules, formula, returns) and avoids redundancy. However, some details like the decay formula and breakdown by memory type could be slightly verbose for a tool description, though they are informative. It's front-loaded with the core purpose, earning its place efficiently.

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 (applies decay rules system-wide or to specific memories) and lack of annotations or output schema, the description does a good job of covering behavior, rules, and returns. It explains the decay logic, formula, and output summary, which compensates for missing structured fields. A minor gap is no explicit error handling or performance considerations.

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

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

The input schema has 100% description coverage, clearly explaining the optional memory_id parameter. The description does not add any parameter-specific semantics beyond what the schema provides (e.g., it doesn't clarify format or examples for memory_id). According to the rules, with high schema coverage, the baseline is 3, which is appropriate here.

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

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

The description clearly states the tool's purpose: 'Apply automatic confidence decay based on last access time.' It specifies the verb ('apply'), resource ('confidence'), and mechanism ('based on last access time'), distinguishing it from siblings like adjust_memento_confidence (manual adjustment) or boost_memento_confidence (increasing confidence).

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 contexts ('System maintenance to keep knowledge base fresh', 'Applying intelligent decay rules', 'Monthly confidence adjustment routine'), which clearly indicate when to use this tool. However, it does not explicitly state when not to use it or name alternatives (e.g., adjust_memento_confidence for manual adjustments), which prevents a score of 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes key behavioral traits: the tool is for increasing confidence (implying mutation), specifies boost mechanics (e.g., base boost amounts, caps, maximum confidence), and outlines usage contexts. However, it lacks details on permissions, error conditions, or response format, which are minor gaps 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 well-structured with clear sections ('Use for:', 'Usage patterns:', 'Boost mechanics:'), making it easy to scan. It is appropriately sized for the tool's complexity, with each sentence adding value (e.g., explaining boost amounts and usage scenarios). However, some redundancy exists (e.g., similar points in 'Use for' and 'Usage patterns'), slightly reducing efficiency.

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

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

Given the tool's moderate complexity (mutation with 4 parameters), no annotations, and no output schema, the description provides good contextual completeness. It covers purpose, usage guidelines, and behavioral mechanics, but lacks details on output (e.g., what is returned after boosting) and error handling, which are minor omissions for an agent's 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?

The input schema has 100% description coverage, so the schema already documents all parameters thoroughly (e.g., memory_id, relationship_id, boost_amount, reason). The description adds minimal value beyond this, as it does not explain parameter interactions or provide additional context not in the schema. The baseline score of 3 is appropriate since the schema handles most of the parameter documentation.

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 the tool's purpose as 'Boost confidence when a memory is successfully used,' which is a specific verb ('boost') applied to a resource ('confidence' of a memory). It clearly distinguishes this from sibling tools like 'adjust_memento_confidence' (which implies broader adjustments) and 'apply_memento_confidence_decay' (which implies reduction), by focusing on reinforcement after successful use.

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 guidance on when to use this tool through sections like 'Use for:' and 'Usage patterns:', listing specific scenarios such as 'After successfully applying a solution' and 'When verifying old information is still valid.' It also implies when not to use it (e.g., for general confidence adjustments or decay) by contrasting with sibling tool names, though it does not name alternatives directly.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes the two-phase process, scoping behavior ('no leakage outside context'), and return format. It doesn't mention rate limits, authentication needs, or error conditions, but provides substantial operational context beyond basic functionality.

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 clear sections (purpose, when to use, how to use, returns), front-loaded with the core functionality. Every sentence earns its place by providing distinct information without redundancy. The formatting enhances readability while maintaining efficiency.

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

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

Given no annotations and no output schema, the description does an excellent job explaining the tool's behavior, usage, and returns. It covers the two-phase process, scoping constraints, and return format. The main gap is lack of explicit error handling or performance characteristics, but overall it's highly complete for a search tool with good parameter documentation.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds meaningful context by explaining the purpose of each parameter ('context root', 'search query within context', 'relationship traversal depth') and provides default values not in the schema. This adds value beyond what the schema provides, justifying a higher score.

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 with specific verbs ('search within context', 'find related memories', 'search only within that set') and distinguishes it from siblings by emphasizing semantic scoping without embeddings. It explicitly differentiates from general search tools like 'search_mementos' by focusing on context-bound searches.

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 includes explicit 'WHEN TO USE' and 'HOW TO USE' sections that provide clear guidance on when to use this tool ('searching within a specific problem context', 'finding solutions in related knowledge') and how to use it with specific parameters. It implicitly distinguishes from sibling tools by focusing on scoped discovery rather than general searches or relationship searches.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It adequately describes the core action (creating typed relationships between mementos) and mentions optional parameters like strength and confidence, but doesn't cover important behavioral aspects such as whether this operation is idempotent, what permissions are required, error conditions, or how conflicts with existing relationships are handled.

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

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

The description is perfectly structured and concise: it starts with the core purpose, provides common relationship types for context, gives clear examples, and lists optional parameters - all in minimal space with zero wasted sentences. Every sentence earns its place by adding practical 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?

For a creation tool with 6 parameters, no annotations, and no output schema, the description is adequate but incomplete. While it covers the core functionality and parameter usage well, it lacks information about what happens after creation (return values, success indicators), error handling, and system constraints. The absence of output schema means the description should ideally mention what to expect upon success.

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

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

With 100% schema description coverage, the baseline is 3. The description adds significant value by explaining the semantics of relationship_type through examples of common types (SOLVES, CAUSES, etc.) and providing concrete usage examples that clarify parameter ordering and optional parameter usage. This goes well beyond what the schema provides about parameter types and constraints.

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 with a specific verb ('Link') and resource ('two mementos with a typed relationship'), distinguishing it from siblings like 'search_memento_relationships_by_context' or 'get_related_mementos' which query rather than create relationships. The description explicitly focuses on creation rather than retrieval or modification.

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

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

The description provides clear context about when to use this tool by listing common relationship types (e.g., SOLVES, CAUSES) and giving concrete examples, which helps the agent understand appropriate scenarios. However, it doesn't explicitly state when NOT to use it or mention alternatives like 'update_memento' for modifying existing relationships.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool deletes a memento and its relationships, implying a destructive operation, but lacks details on permissions needed, irreversibility, error handling, or rate limits. This is a significant gap 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 a single, efficient sentence that directly states the tool's function without unnecessary words. It's front-loaded with the core action and resource, making it easy to parse quickly.

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

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

Given the tool's destructive nature, no annotations, and no output schema, the description is incomplete. It should cover more behavioral aspects like side effects, confirmation needs, or response format to adequately guide the agent, but it only provides a basic action statement.

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

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

The input schema has 100% description coverage, with the 'memory_id' parameter clearly documented. The description doesn't add any extra meaning or context beyond what the schema provides, such as format examples or sourcing tips, so it meets the baseline for high schema coverage.

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 ('Delete') and resource ('a memento and all its relationships'), making the purpose specific and understandable. However, it doesn't explicitly differentiate from sibling tools like 'update_memento' or 'adjust_memento_confidence', which could also involve memento modifications, so it doesn't reach the highest 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 provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing the memory_id), exclusions, or compare it to siblings like 'update_memento' for partial changes, leaving the agent to infer usage context.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes key behavioral traits: it's a read-only operation (implied by 'Find' and 'Returns'), includes filtering capabilities, shows relationships, provides sorting (lowest confidence first), and returns specific data structures. However, it doesn't mention potential limitations like pagination or performance characteristics.

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 clear sections (purpose, use cases, features, returns) and each sentence adds value. It could be slightly more concise by combining some bullet points, but overall it's efficiently organized with no redundant 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?

Given the tool's moderate complexity (2 parameters, no output schema, no annotations), the description provides comprehensive context about what the tool does, when to use it, what features it offers, and what it returns. The only minor gap is the lack of explicit output schema documentation, but the 'Returns' section adequately describes the response structure.

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 fully documents both parameters (threshold and limit). The description adds minimal value beyond the schema by mentioning the default threshold (< 0.3) and that results are sorted by confidence, but doesn't provide additional semantic context about parameter interactions or edge cases.

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 with specific verbs ('Find memories with low confidence scores') and distinguishes it from siblings by focusing on low-confidence filtering rather than general search, creation, or adjustment operations. It explicitly identifies the target resource (memories with low confidence scores).

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 scenarios in a 'Use for' section with four specific contexts (identifying obsolete knowledge, cleanup, quality assurance, review). It clearly indicates when to use this tool versus alternatives by focusing on low-confidence assessment rather than general retrieval or modification tasks.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It adds useful context: the default behavior for 'include_relationships' and an example invocation. However, it doesn't cover other behavioral traits like error handling, permissions needed, rate limits, or what the return format looks like (especially since there's no output schema). This leaves gaps for a tool with mutation siblings.

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 appropriately sized and front-loaded: the first sentence states the core purpose, followed by usage guidance and an example. Every sentence earns its place with no wasted words, making it efficient and easy 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?

Given the tool's moderate complexity (retrieval with an optional parameter), no annotations, and no output schema, the description is somewhat complete but has gaps. It covers purpose, usage, and a parameter default, but lacks details on return values, error cases, or how it fits into the broader memory system with siblings like 'get_related_mementos'. This makes it adequate but not fully 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 description coverage is 100%, so the schema already documents both parameters fully. The description adds minimal value: it mentions the default for 'include_relationships' and provides an example with 'memory_id', but doesn't explain parameter semantics beyond what's in the schema (e.g., format of 'memory_id' or implications of relationships). Baseline 3 is appropriate as the schema does the heavy lifting.

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

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

The description clearly states the tool's purpose: 'Retrieve a specific memento by ID.' It specifies the verb ('Retrieve') and resource ('memento'), distinguishing it from siblings like 'search_mementos' (searching) or 'delete_memento' (deleting). However, it doesn't explicitly differentiate from 'get_related_mementos' or 'recall_mementos', which might also retrieve memories, so it's not fully sibling-distinctive.

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 it: 'Use when you have a memory_id from search results or store_memento.' This gives practical guidance on prerequisites. It doesn't explicitly state when not to use it or name alternatives (e.g., 'get_related_mementos' for relationships without the main memory), so it's not fully comprehensive.

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 of behavioral disclosure. It states the tool retrieves statistics, implying a read-only operation, but doesn't specify if it's safe, requires permissions, has rate limits, or what the output format might be. For a tool with zero annotation coverage, this leaves significant gaps in understanding its 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?

The description is a single, efficient sentence ('Get statistics about the memento database') with no wasted words. It's appropriately sized for a simple tool, though it could be more informative without sacrificing brevity. It's front-loaded but lacks depth.

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 (a statistics tool likely involving aggregated data), no annotations, and no output schema, the description is incomplete. It doesn't explain what statistics are returned, their format, or any behavioral nuances. For a tool with rich potential output and zero structured coverage, this is inadequate.

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

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

The tool has 0 parameters, and schema description coverage is 100%, so there's no need for parameter details in the description. The baseline for 0 parameters is 4, as the description doesn't need to compensate for missing schema information. It appropriately avoids discussing non-existent 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 states the tool's purpose ('Get statistics about the memento database') which is clear but vague. It specifies the verb ('Get') and resource ('memento database') but lacks detail about what kind of statistics or scope. It doesn't differentiate from siblings like 'get_memento' or 'get_recent_memento_activity' beyond the general 'statistics' term.

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

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

No guidance is provided on when to use this tool versus alternatives. It doesn't mention when to prefer this over other get_* tools (e.g., for aggregated data vs. individual records) or any prerequisites. The description offers only a basic purpose without usage context.

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

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

With no annotations provided, the description carries the full burden. It discloses behavioral traits such as the return content ('memory counts by type, recent memories (up to 20), unresolved problems') and default values (implied in examples). However, it lacks details on permissions, rate limits, or error handling, leaving gaps for a tool with no annotation coverage.

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 appropriately sized and front-loaded with the core purpose, followed by return details and examples. Every sentence adds value, but the inclusion of 'EXAMPLES:' as a header slightly disrupts flow. Overall, it's efficient with minimal 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 no annotations, no output schema, and 2 parameters with full schema coverage, the description is moderately complete. It covers the purpose, return content, and usage examples, but lacks details on output structure, error cases, or integration with sibling tools, making it adequate but with clear gaps for a tool in this 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?

The input schema has 100% description coverage, so the baseline is 3. The description adds value by providing examples that clarify usage: 'days=7' for last week and 'days=30, project="/app"' for last month with project filtering. This enhances understanding beyond the schema's technical descriptions, though it doesn't fully explain parameter interactions or constraints.

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: 'Get summary of recent memento activity for session context.' It specifies the verb ('Get summary') and resource ('recent memento activity'), though it doesn't explicitly differentiate from sibling tools like 'get_memento_statistics' or 'get_low_confidence_mementos' beyond the 'recent' and 'session context' qualifiers.

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 usage through the phrase 'for session context' and examples showing time ranges and project filtering, but it doesn't explicitly state when to use this tool versus alternatives like 'get_memento_statistics' or 'search_mementos'. The examples provide context but no clear guidance on exclusions or comparisons.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It describes the filtering and traversal behavior (relationship_types and max_depth), which is useful. However, it lacks details on permissions, rate limits, pagination, or what happens if no matches are found. The examples help but don't fully compensate for missing 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 appropriately sized and front-loaded: the first sentence states the core purpose, followed by concise filtering details, and then practical examples. Every sentence adds value without redundancy, and the structure is clear and 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?

Given no annotations and no output schema, the description is incomplete for a tool with 3 parameters and complex behavior (relationship traversal). It covers the basic purpose and parameters but lacks details on output format, error handling, or advanced usage scenarios. The examples help but don't fully address the complexity.

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

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

Schema description coverage is 100%, so the schema already documents all parameters fully. The description adds minimal value by providing example values (e.g., ['SOLVES'], ['CAUSES']) and clarifying default behavior (max_depth default is 1), but doesn't explain parameter interactions or semantics beyond what the schema provides. Baseline 3 is appropriate given high schema coverage.

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

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

The description clearly states the specific action ('Find mementos connected to a specific memory via relationships') and distinguishes it from siblings like 'get_memento' (which retrieves a single memento) or 'search_memento_relationships_by_context' (which searches by context rather than from a specific memory). It specifies both the resource (mementos) and mechanism (relationships from a memory).

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

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

The description provides clear context for when to use this tool (to find related mementos via relationships from a specific memory) and includes examples that illustrate use cases like finding solutions or root causes. However, it does not explicitly state when NOT to use it or name alternatives among sibling tools (e.g., 'search_memento_relationships_by_context' might be an alternative for broader searches).

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 key behavioral traits: it's a read-only guidance tool (implied by 'Get' and protocol explanation), provides structured onboarding steps, includes optimization targets (avoid 6+ tool calls), and outlines usage contexts. However, it doesn't mention potential limitations like response format or error conditions, which could be useful for an agent.

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

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

The description is front-loaded with a clear purpose statement, but it's lengthy with detailed sections (MEMENTO ONBOARDING PROTOCOL, OPTIMIZED RETRIEVAL, etc.). While informative, some content (like the retrieval flow details) might be more appropriate for a separate guide rather than the tool description itself, reducing conciseness. However, it's well-structured with bullet points and headings.

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 (onboarding for a memory system) and lack of annotations or output schema, the description is highly complete. It covers purpose, usage guidelines, behavioral context (retrieval flows, optimization targets), parameter semantics, and distinctions from other tools. This provides the agent with all necessary context to use the tool effectively without needing additional structured data.

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

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

The input schema has 100% description coverage with a clear enum for the 'topic' parameter. The description adds value by explaining the semantics of each enum value (e.g., 'protocol': Full onboarding protocol, 'retrieval_flow': Optimized retrieval guide), which goes beyond the schema's basic enum list. This helps the agent understand what each topic option returns.

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 the tool's purpose: 'Get comprehensive onboarding protocol for Memento including tool usage guidance, retrieval flow optimization, and best practices.' This is a specific verb ('Get') + resource ('onboarding protocol') that clearly distinguishes it from sibling tools like search_mementos or recall_mementos, which are for actual retrieval operations rather than guidance.

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 guidance on when to use this tool: 'Run memento_onboarding() at session start' and 'USE memento_onboarding(topic="...") for specific guidance' with enumerated topics. It also distinguishes it from alternatives by explaining the retrieval flow for other tools (search_mementos, recall_mementos) and the critical distinction between Memento and Session memory, clarifying this tool's role as onboarding rather than operational.

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 and does well by explaining key behavioral traits: it's 'optimized for fuzzy matching' with automatic handling of 'plurals, tenses, and case variations', specifies what types of knowledge it works with ('long-term knowledge that survives across sessions'), and mentions performance characteristics ('less effective for acronyms, proper nouns, exact technical terms'). It doesn't cover rate limits or authentication needs, but provides substantial behavioral 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 well-structured with clear sections (BEST FOR, USE FOR, etc.) and uses bullet points effectively. While comprehensive, some redundancy exists (e.g., 'Fuzzy/approximate matching' appears in multiple places). Most sentences earn their place by providing distinct guidance, though it could be slightly more concise.

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

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

For a 5-parameter tool with no annotations and no output schema, the description provides substantial context about when and how to use the tool, behavioral characteristics, and alternatives. It covers the tool's strengths and limitations well. The main gap is lack of information about return format or pagination behavior, but given the comprehensive usage guidance, it's mostly 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 description coverage is 100%, so the schema already documents all 5 parameters thoroughly. The description adds minimal parameter-specific information beyond the schema - it mentions the 'query' parameter in examples and implies 'project_path' filtering, but doesn't provide additional semantic context about how parameters affect results. This meets the baseline for high schema coverage.

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

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

The description clearly states the tool's purpose as 'finding mementos using natural language queries' with 'fuzzy matching' capabilities. It distinguishes from sibling tools by specifying this is the 'primary tool' for this function and explicitly mentions 'search_mementos' as an alternative for different use cases, providing clear differentiation.

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 extensive usage guidance with explicit 'BEST FOR', 'USE FOR', 'DO NOT USE FOR', and 'LESS EFFECTIVE FOR' sections. It names specific alternatives ('search_mementos with tags') for cases where this tool is less effective, and includes a 'FALLBACK' recommendation, offering comprehensive 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 provided, the description carries full burden but only states what the tool does without behavioral details. It doesn't disclose whether this is a read-only operation, potential side effects, rate limits, authentication needs, or what the output looks like (especially critical since there's no output schema). The description is purely functional without behavioral 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 a single, efficient sentence that front-loads the core functionality. Every word earns its place by specifying the action, resource, and filtering mechanism without unnecessary elaboration or redundancy.

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

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

For a 7-parameter search tool with no annotations and no output schema, the description is inadequate. It doesn't explain what constitutes a 'memento relationship', how results are returned, pagination behavior, or error conditions. The agent must rely entirely on the input schema for parameter understanding and has no guidance on output format or behavioral characteristics.

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

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

The description lists the four primary context fields (scope, conditions, evidence, components) but doesn't add meaningful semantics beyond what the 100% schema coverage already provides. The schema descriptions comprehensively explain each parameter's purpose, constraints, and examples. The description merely restates parameter names without additional value.

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

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

The description clearly states the tool searches memento relationships using structured context fields (scope, conditions, evidence, components). It specifies the verb 'search' and resource 'memento relationships' with the filtering mechanism. However, it doesn't explicitly differentiate from sibling tools like 'search_mementos' or 'contextual_memento_search', which appear similar.

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 no guidance on when to use this tool versus alternatives like 'search_mementos' or 'contextual_memento_search'. It lacks context about prerequisites, exclusions, or typical use cases, leaving the agent to infer usage from the tool name and parameters alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes key behavioral traits: it's a search/retrieval operation (implied non-destructive), mentions case-insensitive tag normalization, provides search tolerance modes (strict/normal/fuzzy), and includes practical examples. However, it doesn't cover aspects like rate limits, authentication needs, or pagination behavior, 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 and efficiently uses every sentence. It starts with a clear purpose statement, follows with usage guidelines, details parameters with practical notes, provides concrete examples, and ends with an alternative tool recommendation. No wasted text; each section adds distinct value in a logical flow.

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 (11 parameters, no output schema, no annotations), the description does a strong job. It covers purpose, usage guidelines, key parameters with semantics, and behavioral notes like case-insensitive matching. However, it lacks details on output format, error handling, or pagination limits, which would be helpful for a search tool with many parameters.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds value by explaining parameter usage in context: it lists key parameters (tags, memory_types, min_importance, search_tolerance, match_mode) with practical guidance (e.g., 'tags: Filter by exact tag match (most reliable for acronyms)') and provides examples showing how parameters combine. This enhances understanding beyond the schema's technical 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?

The description clearly states the tool performs 'Advanced search with fine-grained filters for precise retrieval of mementos,' specifying both the action (search/retrieval) and resource (mementos). It explicitly distinguishes from its sibling 'recall_mementos' by stating 'USE THIS TOOL FIRST (not recall) when searching for:' specific categories like acronyms and proper nouns, making the differentiation 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 explicit guidance on when to use this tool versus alternatives. It states 'USE THIS TOOL FIRST (not recall) when searching for:' and lists specific use cases (acronyms, proper nouns, known tags, technical terms), and concludes with 'For conceptual/natural language queries, use recall_mementos instead,' clearly defining the boundary with the sibling tool.

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 and does an excellent job disclosing behavioral traits. It explains limits (character counts, tag limits), best practices (tagging acronyms), type constraints (what types to avoid), and return behavior ('Returns memory_id'). It doesn't mention authentication, rate limits, or error handling, but covers most operational aspects well for a creation 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 well-structured with clear sections (Required/Optional, USE FOR/DO NOT USE, LIMITS, TAGGING BEST PRACTICE, Types, Notes, EXAMPLES) and every sentence earns its place. It's appropriately sized for an 8-parameter tool with complex usage considerations. It could be slightly more concise in the type explanations, but overall very 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?

Given the tool's complexity (8 parameters, no annotations, no output schema), the description provides excellent contextual completeness. It covers purpose, usage guidelines, behavioral constraints, parameter semantics with examples, and references to related tools. The only minor gap is lack of output schema explanation, but 'Returns memory_id' provides the essential information needed for an agent to use the tool effectively.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds significant value beyond the schema by: explaining parameter constraints (max lengths, uniqueness requirements), providing tagging best practices with rationale, clarifying type usage with specific examples and restrictions, and giving concrete usage examples. However, it doesn't fully explain the 'context' parameter's structure or purpose.

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 with specific verb+resource ('Store a new memento with context and metadata'), distinguishes it from siblings by specifying it's for creating new mementos (vs. update_memento, delete_memento, etc.), and explicitly lists required parameters. It goes beyond a tautology by explaining what a 'memento' represents in this context.

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 guidance with 'USE FOR: Long-term knowledge that should survive across ALL sessions' and 'DO NOT USE FOR: Temporary session state or project-specific context.' It also references sibling tools ('Use create_memento_relationship to link related memories') and distinguishes when to use specific types vs. alternatives (e.g., 'decision' is not a standalone type).

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 disclosure. It states this is an update operation, implying mutation, but doesn't describe what happens during updates (e.g., whether fields are replaced or merged, if changes are reversible, permission requirements, or error conditions). This leaves significant gaps for a mutation tool with zero annotation coverage.

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

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

The description is a single, efficient sentence that gets straight to the point with zero wasted words. It's appropriately sized for a basic tool description and front-loads the essential information ('Update an existing memento').

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

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

For a mutation tool with 6 parameters, 17% schema coverage, no annotations, and no output schema, the description is inadequate. It doesn't explain the update behavior, parameter meanings, return values, or error handling. Given the complexity and lack of structured documentation, the description should provide more context to be 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 description coverage is only 17% (only 'memory_id' has a description), leaving 5 parameters undocumented in the schema. The description adds no information about parameters beyond what's implied by the tool name, failing to compensate for the low coverage. It doesn't explain what 'title', 'content', 'summary', 'tags', or 'importance' represent or how they affect the update.

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 ('Update') and target resource ('an existing memento'), making the purpose immediately understandable. It distinguishes from siblings like 'create_memento' and 'delete_memento' by specifying it's for existing items, though it doesn't explicitly differentiate from similar update operations like 'adjust_memento_confidence'.

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 no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing memento ID), exclusions, or comparisons to sibling tools like 'adjust_memento_confidence' or 'boost_memento_confidence' that might also modify mementos. Usage is implied but not explicitly defined.

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