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

With no annotations, the description carries the burden and does disclose the core write behavior ('durable', 'shared Notion memory'). However, it omits behavioral details like duplicate rejection (despite allowDuplicate), idempotency retry semantics, and what the operation returns or confirms.

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 structured with an action sentence, a 'USE THIS when' list, and an exclusion clause. Every phrase earns its place and the core purpose is 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?

For a 14-parameter tool with no output schema, the description covers when to use it and content policy well, while the schema documents the parameters. A minor gap is the lack of any statement about return behavior or duplicate handling, though the schema's allowDuplicate and idempotencyKey fields hint at it.

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 79% and individual fields like title, content, agent, and tags already have meaningful descriptions. The tool description adds no per-parameter detail, which is acceptable given the schema's heavy lifting; the coverage baseline of 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 opens with a specific verb+resource: 'Save a new durable memory into the shared Notion memory.' This clearly identifies an add/create operation and sets it apart from sibling tools like memory_update and memory_delete without needing to inspect 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?

It gives explicit 'USE THIS when' triggers (preferences, decisions, conventions, bug fixes, context) and a 'Do NOT' exclusion for secrets and throwaway info. It does not name alternative tools, such as memory_update for editing existing memories, so it stops short of the full when/when-not/alternatives pattern.

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?

There are no annotations, so the description must carry behavior. It states the response-mode behavior (compact returns excerpts) and 'List' implies a read-only operation, but it does not explicitly confirm no side effects, mention auth/access needs, or describe ordering guarantees beyond 'recently updated.'

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?

Three short sentences, front-loaded with the main operation; each adds some value. The compact-mode tip and use-case sentence are useful but mildly redundant with the first sentence and schema.

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 no-output-schema tool with 5 optional params, the description gives the core list behavior and response modes, but omits what an actual result item looks like, default agent scope, and the meaning of 'full' vs 'compact' beyond omission. It is adequate for a simple list but not fully 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?

With 60% schema coverage, the schema documents project, response, and currentProject, but not agent or limit. The description only adds a usage tip for response ('compact... without full content'), which largely repeats the schema, and does not explain the agent scope or default limit.

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 opening sentence names a specific verb ('List') and resource ('most recently updated memories from the shared Notion memory'), so an agent immediately knows the operation and scope. The recency qualifier separates it from sibling search/get tools, even though no sibling is named.

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 last sentence gives a concrete use case: 'Use to get context about what was learned/saved lately.' That is clear context for when to call it, but it does not explicitly contrast with memory_search or memory_get or mention any exclusions.

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 discloses return format, the presence of match.excerpt with Unicode offsets for semantic/hybrid modes, and the behavior of the response parameter. It does not mention side effects (though search implies read-only) or authentication/rate limits, but it covers the essential behavioral traits for correct 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 concise, front-loaded with purpose, and flows logically from what it returns to usage guidance. It avoids redundancy with the schema. It could be slightly more structured with separate sections, but it remains 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 tool with 9 parameters, multiple modes, and alternatives, the description covers the key behavioral aspects: return contents, compact vs full, and when to use. It does not delve into parameter interactions (e.g., currentProject vs project), but the schema covers those. Given the output schema is absent and annotations are missing, the description adequately covers what an agent needs to call it correctly.

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 high (78%), so most parameters are already documented. The description adds value by clarifying the response parameter's purpose ('compact to omit full content') and referencing the mode requirement ('require a fresh local cache'), but these are also in the schema. The baseline of 3 applies because the schema does most of the work.

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 (search), the resource (shared long-term memory in Notion), and the exact return fields (id, title, content, agent, category, tags). It also distinguishes itself from siblings by noting that memory_get provides full content, making it unambiguous what this tool does.

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 instructs to use this tool at the start of a task and before decisions, with relevant keywords. It also references an alternative (memory_get) for full content. However, it does not explicitly state when not to use it relative to memory_recent or memory_delete, so it stops short of a full 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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It says 'update' but does not explain whether this is a PATCH-style partial update or a full replacement, whether omitted fields are preserved, or what side effects occur when updating an archived or superseded memory.

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 no filler; the core action is front-loaded and the usage preference adds meaningful guidance without redundancy. Every word 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?

For a mutation tool with 14 optional parameters, no annotations, and no output schema, the description is too thin. An agent still lacks critical context about update semantics, field preservation, and what constitutes a successful update.

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 7%, yet the description only references 'id' and gives no meaning for the other 13 parameters. It does not compensate for the missing schema descriptions, though it at least identifies id as the lookup key.

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 ('Update') with a specific resource ('existing memory by id'), clearly distinguishing it from siblings like memory_add, memory_delete, and memory_search. The intent is immediately 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?

It explicitly states when to prefer this tool: 'when knowledge changes or gets corrected,' and contrasts it with creating duplicates. This directly guides the agent away from memory_add in the main scenario where duplication would be inappropriate.

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