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

Despite no annotations, the description discloses key behaviors: duplicates are ignored, returns an array of {entityName, addedObservations}, and database context (adds to specified or master database). No contradictions.

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

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

Description is concise with a clear structure: purpose, important note, return value, database context, and examples. Every sentence adds value without redundancy.

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

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

Given no output schema, the description adequately explains return format and behavior. It covers error handling, database context, and duplicate handling. Sufficient for correct invocation.

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

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

Schema coverage is 67% with descriptions, but the description adds value by explaining the return format for observations and providing examples that clarify parameter usage. The baseline is 3 due to schema coverage, but examples elevate it to 4.

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 adds new facts to an existing memory, distinguishing it from sibling tools like aim_memory_store (creates new memory) and aim_memory_remove_facts (removes facts). The verb 'add' and resource 'facts' are specific.

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

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

Explicitly states that memory must already exist and to use aim_memory_store first, plus that it throws an error if not found. Provides clear when-to-use and preconditions. Examples further guide usage.

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

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

With no annotations, the description must cover behavioral traits. It explains that entities are deleted from the knowledge graph and that associated links are also removed. It discusses location override and auto-detection. However, it does not mention irreversibility or return status, which would enhance transparency.

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

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

The description is well-structured with clear sections for database selection and location override, and includes four examples. While it is a bit lengthy, the information is organized and front-loaded, making it 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?

The description covers the operation and parameter details thoroughly but lacks information about the return value or what happens after deletion (e.g., success/failure reporting). Given no output schema, additional context on the outcome would improve completeness for an agent.

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?

All three parameters are described in the schema, and the description adds significant value: context usage is clarified (optional, for specific contexts), location parameter includes explanation of enum values and override behavior, and entityNames is shown in examples with appropriate syntax. The description goes beyond schema definitions.

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

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

The description uses a specific verb 'forget' and resource 'memories', clearly indicating deletion. It differentiates from siblings like aim_memory_store, aim_memory_get, and aim_memory_remove_facts by specifying that it removes both memories and their associated links.

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

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

The description explains when to use the tool with database selection methods (context, location override) and provides multiple examples covering different scenarios (default, work database, global location, etc.). It does not explicitly mention when not to use, but the context and examples sufficiently guide usage.

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

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

No annotations provided, so description carries burden. Discloses silent ignoring of missing names and format options. For a read-only tool, this is sufficient, though could mention safety or auth.

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

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

Well-structured with clear sections, examples, and sibling differentiation. No wasted words.

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

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

Covers all parameters, format, examples, sibling comparison, and return values (entities and relations). Complete for a retrieval tool with no output schema.

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

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

Schema coverage is 100%. Description adds value with examples and explanation of format options and context parameter, going beyond schema.

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

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

Clearly states it retrieves specific memories by exact name. Distinguishes from sibling aim_memory_search by specifying exact vs fuzzy matching.

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

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

Explicitly says when to use (exact name known) and when not (use aim_memory_search for fuzzy). Also notes non-existent names are silently ignored.

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 full responsibility. It discloses key behaviors: duplicates are ignored, returns an array of created relations, requires existing entities, and uses active voice. It does not cover error handling or side effects, but the described behaviors are sufficient for safe invocation.

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-organized with clear sections: purpose, relation structure, important note, returns, database info, and examples. Every sentence adds value, though it is slightly verbose in places. It is front-loaded with key information.

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

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

Given no output schema and moderate complexity, the description covers preconditions (entities must exist), return type (array of relations), and includes multiple examples. It does not explicitly tie into sibling tools, but it is complete enough for an agent to use correctly. Minor omissions like error behavior on missing entities are acceptable given the tool's simplicity.

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

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

Schema coverage is 67%, placing the burden on the description to add meaning. The description enhances parameter semantics by providing example values for relationType, explaining the relation structure (from-relationType-to), and recommending active voice. This goes beyond the schema's basic descriptions.

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

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

The description explicitly states the tool's purpose: 'Link two memories together with a relationship.' and 'Use this to connect related information.' It clearly differentiates from sibling tools like aim_memory_add_facts (which adds facts) and aim_memory_unlink (which removes links) by focusing on creating associations. Examples further clarify the intended 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 clear usage context: how to structure relations with active voice, required preconditions (entities must exist), and where relations are stored (context database or master). It does not explicitly compare to alternatives or state when not to use, but the examples and structure guide usage effectively.

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

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

With no annotations, the description carries the full burden. It discloses database types, naming conventions, and the structure of the return object. No behavioral traits like side effects or permissions are mentioned, but the tool appears read-only and harmless.

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 (DATABASE TYPES, RETURNS, EXAMPLES). Every sentence adds meaningful information, and the format is easily scannable. No fluff.

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

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

Given the tool has no parameters and no output schema, the description fully covers what the tool does, what it returns, and provides an example usage. It is sufficient for an agent to invoke correctly without additional 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 zero parameters, so the baseline is 4. Description adds value by explaining database types and the return format, which helps the agent understand the output without needing explicit 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?

Description uses specific verb 'list' and clearly identifies the resource as 'available memory databases and show current storage location'. It distinguishes itself from sibling tools that perform mutations or queries on individual memories.

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

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

Explicitly states 'Use this to discover what databases exist before querying them', providing clear context for when to invoke this tool. No exclusions or alternatives are given, but the single use case is well-defined.

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. The description does not disclose potential performance impacts for large databases or that this is a read-only operation (though implied by name). It adds some context via format options but misses behavioral traits like rate limits or idempotency.

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

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

The description is well-structured with sections for format options, database info, and examples. It is concise with no redundant sentences; every part adds value.

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

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

The description explains what is returned (memories and links) and provides format options. Without an output schema, it is somewhat vague about the structure, but the examples and format choices compensate. It is sufficient for a read-all tool.

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

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

The input schema has 100% coverage, but the description enhances understanding by explaining the format parameter with examples and clarifying the context parameter's effect. It goes beyond the schema by providing 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 reads all memories and returns them with their links. The verb 'Read' and resource 'all memories' are specific. It distinguishes from sibling tools like aim_memory_get (likely single memory) and aim_memory_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 provides explicit guidance on database selection (context) and format options (json/pretty) with examples. It implies when to use: when you need all memories. However, it does not explicitly state when not to use or compare with alternatives.

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

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

No annotations are provided, so the description carries the full burden. It clearly states that the memory is kept while only selected observations are removed. It explains the database selection behavior and location override logic. However, it does not mention error handling (e.g., if observations don't exist) or permissions, but the core behavior is well disclosed.

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

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

The description is well-structured with sections (DATABASE SELECTION, LOCATION OVERRIDE, EXAMPLES) and uses bullet-like formatting. It avoids tautology and provides necessary context. While slightly lengthy due to examples, each part adds value. Could be more concise, but it's organized and front-loaded.

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

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

Given the tool has 3 parameters, no output schema, and no annotations, the description covers the main behaviors: what the tool does, database/location selection, and multiple examples. It lacks explicit details on error cases or return values, but it is sufficient for an agent to invoke the tool correctly in most scenarios.

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 67% (context and location have descriptions, deletions does not at top level). The description adds value by explaining the deletions parameter through examples and stating that it removes selected observations. It clarifies the structure (array of objects with entityName and observations) and provides multiple usage patterns, enhancing understanding beyond the schema.

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

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

The description clearly states 'Remove specific facts from a memory. Keeps the memory but removes selected observations.' This distinguishes it from siblings like aim_memory_forget (which likely removes entire memory) and aim_memory_add_facts (adds). The verb 'remove' and resource 'facts from a memory' are specific and unambiguous.

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

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

The description provides explicit guidance on when to use the location override and includes examples for different contexts (master, work, health) and locations (project, global). It implies the tool is for selective deletion without removing the entire memory, but does not explicitly state when not to use it compared to siblings like aim_memory_forget. The database selection section also adds 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 provided, but description fully covers behavioral traits: case-insensitive matching, fields searched, format options. No destructive hints needed.

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

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

Well-structured with headings (WHAT IT SEARCHES, VS, FORMAT OPTIONS, EXAMPLES). Informative but could be slightly more concise; however, organization is excellent.

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

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

No output schema, but description covers purpose, usage, parameter semantics, and examples adequately. For a search tool with 4 parameters (100% schema coverage), it is complete.

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

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

Schema coverage is 100%, baseline 3. Description adds examples and clarifies search behavior beyond schema, e.g., how context and location work. Adds significant 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 it searches memories by keyword, specifies what it matches (names, types, facts), and distinguishes from sibling tool aim_memory_get for exact name matching.

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

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

Explicitly states when to use ('when you don't know the exact name') and contrasts with aim_memory_get. Provides examples and format options for different 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?

The description thoroughly discloses behavioral traits: it explains the structure of memories (name, type, observations), the use of 'context' for databases, storage mechanisms (JSONL files, .aim directory, global), and return value (array of created entities). Since no annotations are provided, the description fully covers transparency.

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

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

The description is well-structured with clear sections (WHAT'S STORED, DATABASES, etc.) and front-loaded with the core purpose. While concise for the complexity, it could be slightly trimmed without losing 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 complexity (3 parameters, nested array) and absence of output schema, the description covers all necessary aspects: purpose, parameters, usage patterns, storage details, return values, and examples. It is complete and self-contained.

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

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

The description adds significant meaning beyond the input schema. For 'context', it explains master database and naming conventions. For 'location', it clarifies project/global and automatic detection. For 'entities', it details the nested object structure. Schema coverage is high, but the description enhances understanding with practical guidance.

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

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

The description clearly states the tool's purpose: 'Store new memories... remember people, projects, concepts, or any information worth persisting.' It specifies the verb (store) and resource (memories), and the sibling tools (like aim_memory_add_facts or aim_memory_forget) have different purposes, making it distinguishable.

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 guidance on when to use the tool (to remember information) and includes examples for different scenarios (master database, named context, location). However, it does not explicitly state when not to use it or directly reference sibling tools for alternatives.

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

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

With no annotations, the description carries the full burden. It states the behavioral effect (removes links, keeps memories) and covers parameter behavior via examples. However, it lacks details on reversibility, error cases (e.g., non-existent relations), or permission requirements, leaving some transparency gaps.

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

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

The description is well-structured with sections for database selection, location override, and examples. It is front-loaded with the main purpose. While it is somewhat verbose, all content adds clarity, and the examples are particularly helpful.

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 covers the main function, parameter usage, and key scenarios. It lacks details on return values or error handling, but the provided information is sufficient for correct invocation in typical cases.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by explaining the location parameter with a 'LOCATION OVERRIDE' section and illustrating context and location usage through multiple examples, providing more context than the schema alone.

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 'Remove links between memories' and clarifies that it keeps the memories but removes connections. This clearly differentiates it from siblings like aim_memory_add_facts and aim_memory_remove_facts, which add or remove facts rather than links.

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

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

The description provides database selection guidance and location override details, with examples showing different contexts. However, it does not explicitly state when not to use this tool or directly name alternative tools for comparison, leaving some ambiguity for agents unfamiliar with the domain.

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