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 does state the output type and the all-versus-one-project scoping, which is useful. However, it does not mention side effects, read-only nature, error behavior, or what happens when an invalid project is specified.

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, front-loaded sentence with no filler. Every word adds meaning: the action, the scope alternatives, and the output format are all 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?

For a simple export tool with one optional parameter and no output schema, the description covers the main behavior and output format. It remains incomplete regarding return value details, error conditions, and any limitations (e.g., large exports), which an agent would benefit from knowing.

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 0%, so the description must clarify the 'project' parameter. It does: 'or one project' indicates that the parameter is optional and scopes the export to a single project. It does not explain what format the project value should take (name, id), but it adds meaning beyond the bare 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 a specific action ('Export') applied to a specific resource ('memories') and specifies the output format ('JSON dict'). It also clarifies the optional project scoping, distinguishing it from related tools like import_memories or list_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?

The description gives no guidance on when to choose this tool over siblings such as recall, list_memories, or import_memories. There is no mention of use cases, prerequisites, or scenarios where export is preferred.

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

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

With no annotations, the description carries full behavioral burden. It does disclose that the tool deletes and that a query deletes all matches (via schema description). However, it omits important traits like irreversibility, permission requirements, or potential side effects on related data. For a destructive operation, this is adequate but not rich.

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, focused sentence that leads with the core action. There is no redundant information, and it efficiently conveys the two invocation modes.

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

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

The tool is simple (2 optional params, no output schema), but the description does not clarify interaction between id and query (e.g., exclusive or additive), nor does it mention return behavior. While not critical for a basic delete, the lack of such details leaves some ambiguity 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?

Schema coverage is only 50% (query has a description, id does not). The description partially compensates by clarifying that id is an identifier and query is an FTS match, but it does not specify id format or FTS syntax. It adds meaning beyond the schema but not enough to fully bridge the coverage gap.

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 a specific verb ('Delete'), a resource ('memory'), and two distinct methods (by id or by FTS content match). This clearly differentiates it from siblings like remember, recall, and list_memories, leaving no ambiguity about the tool's role.

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. While the destructive nature is implied by 'Delete', it does not explicitly state conditions like 'use when you want to permanently remove a memory' or warn against using it for reversible operations. Sibling tools exist for creation and retrieval, but no routing logic is given.

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 behavioral transparency burden. The verb 'Return' weakly signals a read-only operation overshadowed by no param dependencies, but it does not disclose whether stats are scoped to all data, whether results are deterministic, or whether any side effects occur. Basic behavior is clear, but deeper transparency is limited.

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 front-loaded sentence: the verb and resource appear first, followed by a compact list of concrete stats. Every word adds value and there is no filler or repetition.

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

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

The tool has no params and no output schema, so the description must clarify what the caller receives. It lists stat categories but not their exact structure, ordering, or labeling, leaving some ambiguity about the response shape and the overall scope of the stats.

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 is empty and parameter count is zero, so the schema coverage is vacuously 100%. Per the baseline for a zero-parameter tool, no additional parameter semantics are needed; the description's aggregate dimensions are not tied to any args.

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 clear verb and resource ('Return aggregate stats') and enumerates meaningful dimensions (total, per-project, per-tag, oldest/newest, most-accessed). It is distinguishable from sibling tools like list_memories, though it never explicitly names the memory domain, which is only implied by the sibling 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?

No guidance is given about when to choose get_stats over list_memories, summarize_session, or other siblings. The aggregation purpose is implicit, but there is no explicit scenario or exclusion to help an agent decide between 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?

Since no annotations are provided, the description carries the full burden, and it does add the duplicate-handling behavior (skip/bump/replace), which is relevant context. It does not define what "bump" means, whether the import merges with existing memories or replaces the whole store, or what happens on invalid JSON.

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

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

Two short sentences with no filler: the verb, resource, and source format are front-loaded, and the on_duplicate line is compact. Every phrase earns its place.

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

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

Given only two parameters and a reasonable schema, this is close to adequate, but the lack of annotations and output schema makes the missing details more costly. An agent still doesn't know whether the import is additive or destructive, what counts as a duplicate, or what the tool returns.

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

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

The schema already describes the data parameter's shape, and the description only restates on_duplicate's allowed values without explaining their semantics, especially "bump." With 50% schema coverage, the description adds modest value but doesn't fully compensate for the missing parameter-level explanation.

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?

States a specific verb (import), resource (memories), and source format (JSON), and mentions the on_duplicate policy, which gives useful differentiation from related tools. It doesn't explicitly contrast with sibling tools like remember or export_memories, but the import-from-JSON framing makes the core purpose clear.

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 phrase "Import memories from JSON" implies this is the tool to use when you have memory data in JSON format to load, and the on_duplicate options give situational choices. However, there is no explicit statement of when to prefer this over remember or export_memories, nor any exclusionary guidance.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only restates that listing is possible. It does not mention read-only behavior, response format, filtering semantics, pagination, or ordering behavior beyond what the schema already shows.

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?

One tight sentence with the main action and capabilities front-loaded, and no filler. It is concise, though it could include more useful detail without becoming bloated.

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

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

With four parameters, no output schema, no annotations, and no schema coverage, a one-sentence description is inadequate. An agent cannot determine how filters interact, what each ordering mode means, or how this tool relates to recall.

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 0%, so the description must compensate, but it only vaguely mentions 'filters and ordering' without identifying tag or project filters or clarifying the order enum values. It adds little meaning beyond the property names in 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?

States a specific verb ('list') and resource ('memories'), and signals optional filters and ordering. It is clear enough to be distinguished from siblings like remember and forget, though it does not explicitly contrast with recall.

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

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

No guidance on when to use list_memories versus alternatives like recall or get_stats. The description implies a batch read operation but provides no exclusions, use cases, or conditions for choosing this 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, the description carries a higher disclosure burden. It conveys that recall is a non-mutating semantic search across all memories, which is useful. However, it does not describe the result format, ordering, or the approximate nature of semantic matching.

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

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

The description is two sentences with no filler. The primary action and the suggested usage context are both front-loaded and every sentence earns its place.

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

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

The main call path is clear for a search tool, but the lack of an output schema and any behavioral annotations means the agent must infer return shape and filtering semantics. It is adequate but not fully complete for confident 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 description adds no parameter-level meaning. It does not clarify how query, tags, project, limit, or min_importance interact, and schema coverage is only 60%, leaving limit and min_importance without descriptive text. The description needed to compensate for this gap but did not.

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 and resource: 'Semantic search across all stored memories.' This clearly identifies the operation and differentiates it from sibling tools like remember or forget, though it does not name an alternative explicitly.

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 gives an actionable use case: 'Use this at the start of a session to recover context from prior sessions.' It provides clear context but does not explicitly state when not to use it or point to alternatives like list_memories or get_stats.

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 behavioral burden. It does establish the key trait — durable, long-term persistence across sessions — which separates this from ephemeral context. However, it does not disclose side behaviors an agent would benefit from knowing before storing overlapping or repeated memories, such as deduplication policy, overwrite behavior for identical content, or any storage limits.

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

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

Two sentences with zero filler. The core action is front-loaded ('Store a long-term memory') and the usage guidance follows immediately. Every word earns its place, giving the agent maximum signal per token.

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

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

For a simple store operation with a fully-documented 5-parameter schema and no output schema, the description plus schema gives an agent everything needed to call it correctly: what to store, when, and how to configure optional fields. The only gap is the absence of any note about what the operation returns or whether duplicates are handled, which is a minor omission given the simplicity of the tool.

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

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

Schema description coverage is 100%, so all five parameters (content, tags, source, project, importance) are already fully documented with defaults, ranges, and enums in the input schema. The description adds no param-level detail beyond the schema, but at full coverage the baseline 3 applies — 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 opens with a specific verb+resource pair ('Store a long-term memory') and immediately distinguishes this write operation from its sibling retrieval and management tools (recall, forget, list_memories) by stating the persistence goal — 'worth recalling in future sessions.' An agent can tell exactly what this tool does and what content belongs in it.

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 second sentence provides explicit triggering conditions — use it when the user states a preference, decision, fact, or piece of context worth recalling. This is clear, concrete context for when to invoke. However, it never names alternatives or states when not to use it (e.g., transient details that belong in session context rather than long-term memory), so it stops short of the explicit exclusions that would earn a 5.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the core mutation (storing memories) but does not mention side effects like duplication, overwriting, or the impact on existing memories. It also omits details about the max_memories limit and whether the operation is deterministic. The description is honest about the main action but lacks depth.

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 purpose with no unnecessary words. It is highly concise and well-structured.

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

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

For a tool that extracts and stores memories from a message list, the description is too sparse. It does not explain the 'project' parameter, the 'max_memories' limit, or what the tool returns (e.g., whether it returns the created memories). An agent would need to inspect the schema further and make assumptions about side effects. The description is incomplete for reliable 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 description coverage is only 33% (only 'messages' has a description). The tool description adds nothing about 'project' or 'max_memories', leaving the agent without any guidance on how to set these parameters or what they control. The description fails to compensate for the low 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 states a specific action ('extract'), a specific resource ('conversation messages'), and a clear outcome ('store them as memories'). This clearly differentiates it from sibling tools like remember (direct storage) and recall (retrieval), making the purpose unambiguous.

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

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

The description provides clear context: use this tool when you have a list of conversation messages and want to extract memories from them. However, it does not explicitly contrast with alternatives like remember or state when not to use it, though the context is clear enough for most agents.

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