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. 'Delete' implies a destructive mutation, but it doesn't specify whether deletion is permanent, reversible, requires permissions, or has side effects (e.g., on linked memories). This is inadequate 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, direct sentence with zero wasted words. It's front-loaded with the core action and resource, making it highly 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?

For a destructive mutation tool with no annotations and no output schema, the description is insufficient. It lacks critical context like deletion consequences, error conditions, or return values, leaving significant gaps for an agent to understand the tool's full 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%, with the parameter 'key' documented as 'The key to delete'. The description adds no additional meaning beyond this, such as key format or examples. With high schema coverage, 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 action ('Delete') and target resource ('a memory by key'), making the purpose unambiguous. However, it doesn't differentiate this destructive operation from sibling tools like 'list_memories' or 'save_memory' beyond the obvious verb difference, missing explicit contrast.

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 to know the key first), when deletion is appropriate, or what happens after deletion, leaving usage context entirely implicit.

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. While it describes the search behavior, it lacks critical information about what 'degrees of separation' means operationally, whether this is a read-only operation, performance characteristics, or what format the results take. For a graph traversal tool with zero annotation coverage, this is inadequate.

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 communicates the core functionality without wasted words. It's appropriately sized for the tool's complexity and gets straight to the point with clear subject-verb-object structure.

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 graph traversal tool with 3 parameters, no annotations, and no output schema, the description is insufficient. It doesn't explain what constitutes a 'degree' in this memory graph, what relationships are traversed, what the output format looks like, or performance considerations. The description should provide more operational context given the complexity of the domain.

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 all parameters are documented in the schema. The description adds minimal value beyond what the schema provides - it mentions 'N degrees' which corresponds to 'max_degrees' and 'starting memory' which corresponds to 'start_key', but doesn't provide additional context about parameter interactions or search 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 action ('Find all memories') and scope ('within N degrees of separation from a starting memory'), providing a specific verb+resource combination. However, it doesn't explicitly differentiate from siblings like 'find_related_memories' or 'get_linked_memories', which likely have overlapping functionality in a memory graph 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 no guidance on when to use this tool versus alternatives. With siblings like 'find_related_memories', 'get_linked_memories', and 'search_by_relationship', there's clear potential for overlap, but the description offers no context about when this specific degree-based search is appropriate versus other relationship-finding 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 of behavioral disclosure. It mentions 'shortest path' but does not explain what constitutes a link, how paths are computed (e.g., algorithm, limitations), or the output format (e.g., list of keys, distance). This leaves significant gaps in understanding the tool's behavior for an AI 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 a single, efficient sentence that directly states the tool's purpose without any redundant or vague language. It is appropriately sized and front-loaded, making it easy for an agent 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 complexity of pathfinding in a memory graph, no annotations, and no output schema, the description is incomplete. It lacks details on link types, path constraints, error handling, or return values, which are crucial for an agent to use this tool effectively in context with siblings like 'link_memories' or 'search_by_relationship'.

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 clear parameter descriptions ('Starting memory key', 'Target memory key'). The description adds no additional meaning beyond the schema, such as explaining key formats or constraints, so it meets the baseline score of 3 where 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 specific action ('find the shortest path') and the resources involved ('between two memories through their links'), distinguishing it from siblings like 'find_memories_within_degrees' or 'get_linked_memories' by focusing on pathfinding rather than direct relationships or content 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 implies usage for pathfinding between linked memories but does not explicitly state when to use this tool versus alternatives like 'search_by_relationship' or 'find_related_memories'. No exclusions or prerequisites are mentioned, leaving the agent to infer context from the tool name and description 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the search mechanisms (content, tags, links) but doesn't describe what 'related' means operationally, how results are ordered, whether it's a read-only operation, or any performance considerations like rate limits. For a tool with 6 parameters and no 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 that front-loads the core purpose without unnecessary words. Every part ('Find memories related to a given memory through content, tags, or links') contributes directly to understanding the tool's function, making it highly concise and well-structured.

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

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

Given the tool's complexity (6 parameters, no annotations, no output schema), the description is insufficient. It doesn't explain what 'related' entails, how similarity is calculated, the format of results, or error conditions. Without annotations or an output schema, the description should provide more behavioral and operational context to be complete for effective agent 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 description coverage is 100%, so the schema fully documents all 6 parameters. The description adds minimal value beyond the schema—it implies parameters for content, tags, and links but doesn't explain their interactions or provide additional context. With high schema coverage, the baseline score of 3 is appropriate, as the description doesn't compensate for any gaps.

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: 'Find memories related to a given memory through content, tags, or links.' It specifies the verb ('find'), resource ('memories'), and mechanism ('through content, tags, or links'), which distinguishes it from generic search tools. However, it doesn't explicitly differentiate from siblings like 'find_memories_within_degrees' or 'get_linked_memories', which likely have overlapping 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 no guidance on when to use this tool versus alternatives. It doesn't mention when this tool is appropriate compared to siblings like 'find_memories_within_degrees', 'get_linked_memories', or 'search_by_relationship', nor does it specify prerequisites or exclusions. The agent must infer usage from the 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 but offers minimal information. It doesn't specify whether this is a read-only operation, what permissions might be required, whether results are paginated, or what format the returned memories will have. The description only states what the tool does at a high level without operational details.

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

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

The description is extremely concise - a single sentence that directly states the tool's purpose without any unnecessary words. It's front-loaded with the core functionality and wastes no space on 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?

For a tool with 2 parameters, no annotations, and no output schema, the description is insufficiently complete. It doesn't explain what constitutes a 'memory' in this system, what 'linked' means operationally, what relationship types might be available, or what format the results will take. The agent would need to guess about many aspects of tool 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?

The schema description coverage is 100%, so both parameters are documented in the schema itself. The description doesn't add any meaningful parameter semantics beyond what the schema already provides - it mentions 'source memory' and 'relationship type' but doesn't explain these concepts further or provide usage examples.

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 ('Get') and resource ('memories linked from a source memory'), making it immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'find_related_memories' or 'search_by_relationship', which appear to have overlapping functionality in the memory domain.

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. With multiple sibling tools dealing with memory relationships (e.g., 'find_related_memories', 'search_by_relationship', 'find_memory_path'), the agent receives no help in selecting the appropriate tool for different 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 provided, the description carries the full burden of behavioral disclosure. It states the tool creates a link, implying a write operation, but doesn't mention potential side effects (e.g., if duplicates are allowed), error conditions, or what happens on success. This leaves significant gaps in understanding how the tool behaves beyond its basic function.

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 action without unnecessary words. It directly communicates the tool's purpose, making it easy to parse and understand quickly, with no wasted verbiage.

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 a write operation with no annotations and no output schema, the description is incomplete. It doesn't explain what the tool returns, error handling, or constraints like memory existence, leaving the agent with insufficient context to use it effectively beyond basic 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?

The schema description coverage is 100%, with clear descriptions for each parameter (e.g., 'source memory key'). The description adds minimal value beyond this, mentioning 'relationship type' with an example but not elaborating further. This meets the baseline of 3 since 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 action ('Create a link') and the resources involved ('between two memories'), with a specific verb+resource combination. It distinguishes from siblings like 'get_linked_memories' (which retrieves) or 'search_by_relationship' (which searches), but doesn't explicitly contrast with them, keeping it at 4 rather than 5.

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_by_relationship' or 'get_linked_memories', nor does it mention prerequisites such as needing existing memories. It only states what the tool does, not when to apply it, resulting in minimal 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?

No annotations are provided, so the description carries the full burden. It states the tool lists tags but doesn't disclose behavioral traits such as whether it's read-only, how results are formatted (e.g., sorted, paginated), or any performance considerations. This leaves gaps in understanding the tool's operation beyond its basic purpose.

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 purpose ('List all unique tags') without any wasted words. It's appropriately sized for a simple tool and communicates the essential information clearly and directly.

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 low complexity (0 parameters, no output schema, no annotations), the description is minimally complete but lacks depth. It states what the tool does but doesn't cover behavioral aspects like output format or usage context, which could be helpful for an agent despite the simplicity. It's adequate but with clear gaps in transparency.

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 0 parameters with 100% coverage, so no parameter documentation is needed. The description doesn't add parameter details, which is appropriate here, but it could have mentioned if there are implicit constraints (e.g., no filters). Baseline is 4 for zero parameters, as the schema fully covers the absence of inputs.

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 ('List all unique tags') and the resource ('used across all memories'), distinguishing it from sibling tools like list_memories or search_memory_content. It precisely communicates the tool's function without ambiguity.

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 by specifying 'across all memories,' suggesting it's for retrieving a comprehensive tag list rather than filtered results. However, it lacks explicit guidance on when to use this versus alternatives like search_by_relationship or when not to use it, leaving some context to inference.

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 mentions listing keys with optional tag filtering, but doesn't disclose behavioral traits such as whether this is a read-only operation, if it requires authentication, rate limits, pagination, or the format of returned data. For a tool with no 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 that front-loads the core purpose ('List all memory keys') and adds qualifying detail ('optionally filtered by tag'). There is no wasted verbiage, and it is appropriately sized for the tool's 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 the lack of annotations and output schema, the description is incomplete. It doesn't explain what a 'memory key' entails, the return format, or behavioral aspects like safety or performance. For a tool in a memory management context with multiple siblings, more context is needed to fully understand its role and limitations.

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 minimal value beyond the input schema, which has 100% coverage and documents the single optional 'tag' parameter clearly. The description mentions 'optionally filtered by tag', aligning with the schema but not providing additional semantics like tag format examples or filtering logic. With high schema coverage, 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 action ('List') and resource ('memory keys'), with optional filtering capability. It distinguishes from siblings like 'list_all_tags' (which lists tags, not memories) and 'search_memory_content' (which searches content, not keys), but doesn't explicitly differentiate from 'find_memories_within_degrees' or 'find_related_memories' which might also list memories with different filtering logic.

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 when needing to list memory keys, possibly with tag filtering. However, it doesn't provide explicit guidance on when to use this tool versus alternatives like 'find_related_memories' or 'search_memory_content', nor does it mention prerequisites or exclusions. The context is clear but lacks comparative direction.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions retrieval and optional inclusion of related memories, but doesn't cover critical aspects like error behavior (e.g., what happens if the key doesn't exist), performance characteristics, authentication needs, or rate limits. For a read operation with no annotation coverage, this leaves significant gaps in understanding how the tool behaves.

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 purpose ('Retrieve a value by key from memory') and adds a useful qualifier ('with optional related memories'). There is no wasted verbiage, and every word contributes to understanding the tool's function.

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 (3 parameters, no output schema, no annotations), the description is minimally adequate. It covers the basic purpose but lacks details on return values, error handling, and behavioral nuances. Without annotations or output schema, the agent must rely on the description alone, which is incomplete for safe and effective 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 description coverage is 100%, so the schema already documents all three parameters thoroughly. The description adds no additional semantic context beyond what's in the schema—it mentions 'optional related memories' which aligns with the 'include_related' parameter but doesn't explain what 'related' means or how 'max_related' interacts with it. 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: 'Retrieve a value by key from memory' specifies the verb (retrieve) and resource (value from memory). It distinguishes from siblings like 'delete_memory' (destructive) and 'list_memories' (bulk retrieval), but doesn't explicitly differentiate from 'get_linked_memories' or 'find_related_memories' which have overlapping retrieval functions.

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 'with optional related memories,' suggesting this tool is for retrieving specific memories and potentially their context. However, it doesn't provide explicit guidance on when to use this versus alternatives like 'find_related_memories' or 'get_linked_memories,' leaving the agent to infer based on parameter names.

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 implies a write/mutation operation ('Save') but doesn't specify if this overwrites existing keys, requires permissions, has rate limits, or what happens on success/failure. The optional features (tags, expiration) are mentioned but without details on their effects or defaults.

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 purpose and succinctly lists optional features. Every word serves a purpose with no redundancy or unnecessary elaboration, 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?

For a mutation tool with no annotations and no output schema, the description is incomplete. It doesn't explain what the tool returns, error conditions, or behavioral nuances like overwrite behavior. Given the complexity of memory operations and lack of structured data, more context is needed for effective 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 description coverage is 100%, so the schema fully documents all 4 parameters. The description adds minimal value by naming the optional features ('tags' and 'expiration'), but doesn't provide additional context beyond what's in the schema descriptions. 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 action ('Save a value with a key to memory') and resource ('memory'), making the purpose immediately understandable. It distinguishes from siblings like 'delete_memory' or 'recall_memory' by specifying a save/write operation. However, it doesn't explicitly contrast with tools like 'link_memories' or 'search_memory_content', which slightly reduces 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 no guidance on when to use this tool versus alternatives. It mentions optional features (tags and expiration) but doesn't indicate scenarios where this is preferred over other memory tools like 'list_memories' or 'search_memory_content'. There's no mention of prerequisites, constraints, or typical use 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 of behavioral disclosure. It states the tool searches based on relationship patterns, but doesn't describe what 'memories' are, the format of results, whether it's read-only or has side effects, error conditions, or performance characteristics. For a search 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 that directly states the tool's purpose without unnecessary words. It's appropriately sized and front-loaded, with every part contributing to understanding the core functionality. No waste or redundancy is present.

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 searching relationship patterns, lack of annotations, and no output schema, the description is incomplete. It doesn't explain what 'memories' entail, the result format, or how relationship patterns are defined beyond the schema's parameter hint. For a tool with one parameter but significant conceptual depth, more context is needed to fully understand its 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?

The input schema has 100% description coverage, with the 'pattern' parameter fully documented in the schema ('Pattern in format "source relationship target" (use * for wildcards)'). The description adds no additional meaning beyond this, as it only mentions 'relationship patterns' without detailing the parameter. Baseline 3 is appropriate since 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 action ('Search for memories') and the resource type ('memories'), specifying it's based on 'relationship patterns'. It distinguishes from siblings like 'search_memory_content' (which searches content) and 'find_related_memories' (which finds related memories without pattern specification). However, it doesn't explicitly contrast with all siblings like 'find_memories_within_degrees' or 'find_memory_path', leaving some ambiguity.

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 scenarios where this tool is preferred over siblings like 'find_related_memories' or 'search_memory_content', nor does it specify prerequisites or exclusions. Usage is implied by the name and description but not explicitly 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions 'fuzzy search', which hints at approximate matching, but doesn't explain what 'memory content' entails, how results are returned (e.g., format, pagination), error conditions, or performance implications. This leaves significant gaps in understanding the tool's 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: 'Search memory content using fuzzy search'. It is front-loaded with the core action and resource, with no wasted words or unnecessary elaboration, making it highly concise and well-structured.

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

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

Given the complexity of search operations and the lack of annotations and output schema, the description is insufficient. It doesn't cover what 'memory content' includes, how results are structured, limitations of fuzzy search, or error handling. For a tool with no structured behavioral data, this leaves the agent poorly informed about how to use it 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?

The input schema has 100% description coverage, with the 'query' parameter documented as 'The search query'. The description adds no additional meaning beyond this, such as examples of valid queries or how fuzzy search affects query interpretation. With high schema coverage, the baseline score of 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 states the tool's purpose as 'Search memory content using fuzzy search', which includes a verb ('Search') and resource ('memory content'), making it clear what it does. However, it doesn't differentiate from sibling tools like 'find_memories_within_degrees', 'find_related_memories', or 'search_by_relationship', leaving ambiguity about when to use this specific search method versus others.

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. With multiple sibling tools related to searching or finding memories (e.g., 'find_memories_within_degrees', 'find_related_memories', 'search_by_relationship'), there is no indication of when fuzzy search is preferred, what contexts it applies to, or any prerequisites or exclusions.

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