Gnosem

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

With no annotations, the description carries full burden. It explains the soft-delete behavior and its effects on search/list and vector index. Lacks details on permissions or reversibility, but sufficient for a simple tool.

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

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

Two sentences, front-loaded with the action, and concise explanation of side effects. 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?

For a single-parameter tool with no output schema, the description covers the operation and its implications fully. No gaps identified.

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% (only 'id' parameter described as UUID). The description does not add additional meaning beyond what the schema already provides, so baseline 3 applies.

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 'soft-delete a memory by id' and explains the implications (retained for audit, excluded from search/list, removed from vector index). This distinguishes it from siblings like memory_write or memory_list.

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 forgetting a memory but does not explicitly state when to use this tool versus alternatives (e.g., when not to use, prerequisites, or that it's reversible). No guidance on 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 exist, so the description carries the burden. It discloses the read-only nature implicitly by describing 'listing', but does not mention side effects, rate limits, or authorization needs. It does explain the SQL-level filtering and the shape similarity to memory_search.

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

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

Two concise sentences that front-load the purpose and provide necessary detail without redundancy. Every sentence serves a purpose.

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 8 optional parameters, the description adequately covers the listing behavior, filter semantics, and references a sibling for shape. Missing details like default 'recent' window are minor.

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 8 parameters. The description adds only a general note that filters narrow at the SQL level, which adds minimal extra meaning beyond the schema.

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

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

The description clearly states the verb 'list', the resource 'memories', and key behavior 'in reverse chronological order'. It distinguishes from siblings like memory_search and memory_write by specifying the listing orientation.

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 indicates use for 'browsing or catching up', which guides the agent on when to invoke. It mentions optional filters for narrowing, but does not explicitly state when to use 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 fully bears the burden. It discloses the hybrid RRF algorithm, exclusion of forgotten/superseded memories, default compression, and filter behavior. This is comprehensive.

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

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

The description is a single dense paragraph that front-loads the key mode information. It is efficient but slightly packed; breaking into bullet points could improve readability without adding length.

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

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

Given 9 parameters, no output schema, and no annotations, the description covers retrieval behavior, modes, filters, and exclusions thoroughly. It could hint at return format (e.g., list of memory objects) but overall is sufficient.

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

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

Schema coverage is 100%, and the description adds valuable context for many params (e.g., query interpretation per mode, tags AND semantics, filter timing). Some params like k have only default info, but overall enhancement is good.

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 that the tool searches memories, details the default hybrid mode, and contrasts with sibling tools like memory_write and memory_list by focusing on retrieval.

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 hybrid vs semantic vs keyword modes, and mentions optional filters. However, it does not explicitly state when not to use this tool or direct users to alternatives like memory_list for listing all memories.

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?

Despite no annotations, the description explains the core behavior: old row is marked superseded and excluded from future reads, new row becomes current. It lacks details on permissions or reversibility, but for a simple operation this is sufficient.

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 that efficiently convey purpose, behavior, and usage guidance without any unnecessary words.

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

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

Given the absence of output schema and annotations, the description adequately covers purpose, usage, and behavior. It could be improved by documenting optional parameters, but essentials are handled.

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 clarifies the two required parameters ('old_id' as UUID to replace, 'new_content' as new content). However, schema coverage is only 40% (optional params like tags, session_id, written_by lack schema descriptions and are not mentioned in the description).

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

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

The description clearly states the tool's action ('Replace a stale memory with a corrected one') and specifies the resource (memory). It also distinguishes itself from the sibling tool memory_forget, which is used for pure deletions.

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

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

The description explicitly says 'Use for corrections; use memory_forget for pure deletions,' providing clear guidance on when to use this tool versus an alternative.

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 disclose all behavioral aspects. It does so thoroughly: automatic compression for long content (>400 chars), two-stage dedup (byte-identical SHA-256 then semantic embedding), bypass options (force, no_optimize), and the exact response structure (id, exact_duplicate, deduped, matched_score). 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?

The description is slightly long but well-organized: purpose first, then usage details, then specific behaviors. Every sentence adds value, and it avoids fluff. Could be tightened slightly, but the density of information warrants the length.

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 6 parameters (1 required) and no output schema, the description covers all aspects: purpose, parameter behavior, dedup logic, compression, and return fields. It also addresses cross-model access (any MCP client can read). No missing context given the tool's complexity.

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

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

Schema coverage is 100%, but the description adds substantial meaning beyond field labels. It explains why written_by and session_id matter, how no_optimize bypasses compression, how force overrides dedup, and the dedup threshold (cosine ≥ 0.85). This transforms opaque parameters into actionable guidance.

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

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

The description starts with 'Save a fact, preference, decision, or note to the user's cross-model memory,' clearly defining the action (save) and target (memory). It distinguishes from siblings like memory_list or memory_search by focusing on writing rather than reading or querying. The verb 'save' is specific and appropriate.

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 excellent usage guidance: recommending written_by for provenance, session_id for grouping, explaining when to use force or no_optimize, and noting memory_supersede for corrections. However, it does not explicitly contrast with sibling tools like memory_list (when to read vs write), so it slightly misses perfect clarity on when to choose this tool over others.

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

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

Despite no annotations, the description is highly transparent: it details parallel embeddings, batched D1 inserts, return format for success/dedup/error, and free-tier limit handling. No contradictions exist.

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 paragraph that efficiently conveys key information. While it could be broken into sections for readability, it is front-loaded with the core action and avoids unnecessary 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?

Given the lack of an output schema, the description thoroughly explains the return format and handles edge cases (dedup, failure, free-tier limit). All important aspects are covered.

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

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

Schema coverage is 100% with descriptions for each field. The description adds value by explaining dedup behavior, parallel execution, and return structure, going beyond the schema to provide operational context.

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

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

The description clearly states that this tool writes up to 50 memories in a single call, using the same path as memory_write. This distinguishes it from the sibling tool memory_write, 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 explains that it runs the same path as memory_write, includes dedup behavior and force option, and discusses free-tier limits. However, it does not explicitly state when to choose this bulk version over the single memory_write, relying on the name and context to imply bulk scenarios.

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