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

With no annotations, the description carries the transparency burden. It communicates that the memory is 'durable' and stored in 'shared Notion memory,' which conveys persistence and storage location. It also adds content policy guidance ('Do NOT store secrets, tokens, or throwaway information') and even specifies bugfix records should include root cause + fix. It does not describe the write response or failure behavior, but the core mutation behavior is 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?

Two sentences carry all necessary information: the first states the action and target, the second lists concrete triggers and exclusions. Everything included is purposeful and front-loaded, with no filler or redundancy.

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

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

For a create-only tool with six parameters and no annotations or output schema, the description gives strong when-to-use context, content policy, and storage destination. It does not explicitly direct agents to memory_update for editing existing memories or describe the call's return behavior, but the core information needed to invoke this tool correctly is present.

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%, so the description is partly responsible for parameter meaning. It adds useful content-level semantics, such as storing root cause + fix for bugfixes and avoiding secrets, which informs the content parameter. However, it does not clarify the category or importance enums, and those parameters have no schema descriptions. This is partial compensation, not complete.

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 begins with a specific verb and resource: 'Save a new durable memory into the shared Notion memory.' The word 'new' clearly marks this as a create operation, distinguishing it from siblings like memory_update and memory_delete, and 'durable' and 'shared' add scope. This is unambiguous and well differentiated.

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 lists when to use the tool: user preferences, project decisions, conventions, non-obvious bug fixes, and learned context. It also provides a clear exclusion: do not store secrets, tokens, or throwaway information. This gives an agent decisive routing criteria without needing to infer.

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

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

With no annotations provided, the description carries the full burden. It explains the behavior of the hard parameter (archive vs. trash) and the default action, which is useful. However, it does not disclose potential side effects like reversibility or permission requirements, leaving some behavioral details unstated. This is adequate but not exhaustive.

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 wasted words. The primary action and default behavior are front-loaded, followed by a concise usage guideline. Every word earns its place, making it efficient and easy to parse.

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

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

For a simple deletion tool with no output schema, the description covers the essential behavior and the when-to-use scenario. It clarifies the two operational modes and the parameter semantics. Minor gaps like explicit side effects or prerequisites are not critical given the tool's simplicity, so it feels largely 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 50%: the id parameter is described in the schema, but the hard parameter is not. The description adds meaningful semantic detail for hard by explaining that hard=true moves to Notion trash, and it clarifies the default archive behavior. This compensates for the missing schema description and goes beyond a bare boolean.

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: archive a memory by default, or move it to Notion trash with hard=true. It identifies the resource (memory) and the two operational modes, making the tool's purpose unambiguous and distinct from siblings like memory_update or memory_add.

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 when-to-use guidance: 'Use when a memory is wrong or obsolete.' This gives a clear context for selecting this tool, though it does not mention when not to use it or alternative tools. It stops short of naming siblings or exclusion scenarios, so a 4 is appropriate.

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. It communicates that the operation is a read ('Fetch') and that the returned content is complete rather than truncated ('full content'). However, it does not describe what happens for a missing or invalid id, permission requirements, or any response format 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 a single sentence with no wasted words. The core action, target, selector, and output qualifier are all front-loaded, making it easy for an agent to quickly grasp the tool's 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?

For a one-parameter get-by-id operation, the description is nearly complete: it states the input, the action, and the nature of the output ('full content'). The only meaningful omission is behavior for missing or invalid ids, but given the low complexity and fully covered schema, the description is adequately contextual.

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%, and the schema already documents the id as 'Notion page id of the memory.' The description merely refers to 'its id' and adds no new semantic detail beyond what the input schema already provides, so 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 states a specific verb ('Fetch'), a specific resource ('a single memory'), and a precise selection mechanism ('by its id'), plus the notable qualifier 'full content.' This clearly differentiates memory_get from siblings like memory_search, memory_recent, and the mutation tools without requiring an agent to open their schemas.

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 'by its id' implies the tool should be used when an agent already knows the memory's id, but it does not explicitly contrast this with memory_search, memory_recent, or the mutation tools. Usage context is implied rather than stated, so no clear when-not or alternative guidance is provided.

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 present, the description carries the behavioral disclosure burden. It does convey that results are limited to recently updated memories and that the tool is a non-mutating list operation, but it does not mention ordering details, limits, or that no writes occur. The verb 'List' implies read-only behavior, but more explicit transparency would be stronger.

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 focused sentences with no filler. The core function is front-loaded, and the usage context appears in the second sentence, making it quick for an agent to parse and act on.

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 only two optional parameters and no output schema, so the description is reasonably complete for a simple list operation. However, because there are no annotations, the description could more fully address what 'agent' means in this context and how the limit affects results. It provides adequate but not thorough guidance.

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 should compensate for the undocumented parameters. Neither 'agent' nor 'limit' is mentioned, and the description adds no meaning beyond the raw parameter names, defaults, and enum values already present in the schema. The tool is simple enough that the schema partially covers meaning, but the description misses the opportunity to explain filtering or limiting behavior.

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 the specific verb 'List' and the resource 'most recently updated memories from the shared Notion memory,' clearly identifying the tool's function. The phrase 'what was learned/saved lately' reinforces the recency dimension, which differentiates it from siblings like memory_get, memory_search, and memory_add.

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, 'Use to get context about what was learned/saved lately,' provides a clear intended use case. It does not name alternatives or explicitly say when not to use this tool, but the stated use case is enough to guide an agent toward this tool for recency-oriented 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 present, so the description carries the full burden. It discloses that this searches shared cross-agent memory and specifies the returned fields. It does not mention pagination, result ordering, limit behavior, or explicitly confirm read-only semantics beyond the verb '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 sentences, front-loaded with the action and resource, no filler. The parenthetical tool list adds useful scope context while remaining compact.

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 search tool with no output schema, it compensates by enumerating return fields and giving cross-agent context plus usage timing. It leaves minor gaps such as ordering and limit semantics, but these are partially covered by the schema, making it complete enough for 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 covers 60% of parameters with descriptions for query, tag, and agent, while limit and category rely on schema metadata. The description adds no parameter-level guidance beyond listing returned fields like category and tags, so it stays at baseline without compensating for the coverage 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 states a clear action ('Search') and specific resource ('shared long-term memory stored in Notion') and lists the returned fields. It does not explicitly contrast itself with siblings like memory_get or memory_recent, so it misses the top score for sibling 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?

It gives an explicit directive: use at the start of a task with relevant keywords and before decisions, with concrete goals such as reusing saved preferences, conventions, and past decisions. It provides clear usage context but no 'when not to use' guidance or named 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 alone must convey behavior. While it indicates a mutation ('update'), it does not explain whether updates are partial (PATCH-style) or full replacements, what happens if the id does not exist, or whether unspecified fields are preserved or cleared. These are consequential unknowns for an agent making memory edits.

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 only two sentences long and each one contributes: the first states the operation and target, the second gives the usage preference. It is efficiently front-loaded with the core action. No redundant or filler content.

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 eight parameters, no output schema, no annotations, and low schema coverage, the description is materially incomplete. It omits return values, error behavior for missing ids, update semantics (merge vs replace), and any field-specific nuances. An agent could unintentionally overwrite existing memory content because the tool's behavior on omitted fields is unspecified.

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 13%, with just 'id' documented; the other seven parameters (tags, agent, title, status, content, category, importance) have no descriptions. The tool description adds no parameter detail whatsoever, so the agent must infer semantics from names and enums alone. This is especially risky for fields like status and category where replacement semantics matter.

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 pairing, 'Update an existing memory by id,' which clearly distinguishes it from siblings like memory_add and memory_delete. It identifies the resource (memory) and the operation (update) unambiguously.

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, 'Prefer updating over creating duplicates when knowledge changes or gets corrected,' provides an explicit routing rule. It tells the agent when to choose this tool over memory_add, giving both a condition and an alternative. This is strong guidance above the bare minimum.

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