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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the tool is known to be safe and idempotent. The description adds behavioral context by specifying it is machine-readable, to be called first, and that it supports privacy_mode documentation—details not in the annotations. There is no contradiction with annotations.

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, front-loading the core purpose ('Machine-readable install and operating instructions for AI agents') before adding usage guidance. Every sentence adds value with no redundancy, making it 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 simple tool with one parameter and no output schema, the description provides the essential usage context: when to call it and a special feature (privacy_mode). It lacks details on what the manifest contains or how to interpret it, but given the tool's simplicity and annotations covering safety, it is reasonably 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 description coverage is 0%, meaning the description provides no explanation of the 'client' parameter. The description does not mention the parameter at all, leaving the agent to rely solely on the schema's enum and default. Since the description should compensate for low schema coverage but does not, the parameter semantics are poorly communicated.

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: it provides machine-readable install and operating instructions for AI agents. It also indicates it should be called first during onboarding, which is a clear directive. While it doesn't explicitly differentiate from siblings, the onboarding context and manifest nature make the purpose distinct enough.

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 'Call first when onboarding,' giving a clear when-to-use signal. It also mentions support for privacy_mode documentation, hinting at a specific use case for read tools. However, it does not state when not to use it or name alternative tools, though the manifest's role as an initial reference is implicit.

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?

Annotations already declare readOnlyHint=true, openWorldHint=false, and idempotentHint=true, covering safety and idempotency. The description adds that it reports on 'privacy modes and mutation gating', which goes beyond the annotations and provides useful behavioral context. However, it does not elaborate on what these modes mean or how the mutation gating is represented, so it adds limited detail beyond the annotations.

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 filler. It front-loads the core purpose ('self-description') and immediately names the key inclusions. Every word contributes to understanding the tool's role, making it highly efficient.

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 tool with one optional parameter and no output schema, the description is largely complete. It states the tool's purpose and key aspects (privacy modes, mutation gating), and the annotations cover read-only and idempotency. The only minor gap is that it does not indicate whether the output is a structured manifest or a free-text summary, but given the simplicity, this is acceptable.

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 description coverage is 100%, and the single parameter 'privacy_mode' is fully documented in the schema with its enum values and explanations. The tool description does not add any additional meaning beyond what the schema already provides, so the baseline 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 clearly identifies the tool as a self-description of the MCP, specifying it includes privacy modes and mutation gating. This distinguishes it from the sibling tools that perform memory operations (get, set, search, etc.), so an agent can tell it apart. It is not a tautology and names concrete aspects, though it could be more explicit about the exact return format.

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 provided on when to use this tool versus alternatives. It does not mention that it is suitable for discovering capabilities or checking mutation restrictions, nor does it exclude any scenario. An agent must infer its purpose from the description alone, which is minimal.

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?

Annotations already declare readOnlyHint and idempotentHint, covering the safety profile. The description adds behavioral context beyond these: it is a lightweight check that does not read entry values and verifies path readiness and size. This is consistent with the annotations and adds value without contradiction.

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 concise sentences that front-load the core purpose ('Local SQLite path readiness and size') and include a critical usage note ('Safe first call every session'). There is no wasted wording, making it highly efficient.

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 status-check tool with one optional parameter and no output schema, the description covers the essential behavior and usage guidance. It does not describe the return format, but for a readiness/size check an agent can reasonably infer a JSON status object. The absence of output schema reduces the need for detailed return documentation.

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 parameter privacy_mode is fully documented in the schema. The description does not add any additional meaning about the parameter, so it relies on the schema. Baseline 3 is appropriate since 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 clearly states the tool's function: checking 'Local SQLite path readiness and size' while explicitly noting it does so 'without reading entry values'. This distinguishes it from data-access siblings like memory_get and memory_list. It could be more explicit about being a status/health check, but the purpose is 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 phrase 'Safe first call every session' provides clear usage context, recommending it as an initial lightweight check before other operations. It also implicitly differentiates from siblings by noting it avoids reading entry values, but it does not explicitly name alternatives or state when not to use it. This meets the 'clear context, no exclusions' level.

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?

Annotations already declare readOnlyHint and idempotentHint. The description adds the static nature ('Static inventory') and explicitly states 'No live value reads', which reinforces and extends the read-only behavior with useful context about the tool's non-dynamic character. This adds value beyond the annotations.

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?

A single sentence that is fully front-loaded with the core purpose and explicitly disclaims live reads. Every word contributes to understanding, with 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 is simple, with one optional parameter and no output schema. The description adequately conveys its purpose as a static inventory and mentions the key elements (domains, privacy modes, recommended first calls). It could specify the exact output structure, but given the simplicity and the fact that it's an inventory, the description is sufficiently complete for an agent 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?

The schema has 100% coverage with a detailed description of the privacy_mode parameter. The tool description adds no additional information about the parameter beyond referencing privacy modes, so it does not go beyond what the schema already provides. Baseline 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 clearly states the tool provides a static inventory of memory domains, privacy modes, and recommended first calls, and explicitly differentiates it from live data reads. This distinguishes it from siblings like memory_get and memory_list, which likely perform dynamic reads.

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 getting an overview or starting point ('recommended first calls'), but does not explicitly state when to use it versus alternatives or when not to use it. There is no naming of sibling tools or exclusion conditions, leaving some ambiguity.

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?

Annotations already declare readOnlyHint and idempotentHint, so the description does not need to restate these. It adds the behavioral detail of an optional since/until window and reinforces the explicit_user_intent requirement, which is already in the schema. Beyond that, it does not disclose additional behaviors like error handling or output structure, so it adds modest value over the annotations.

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 redundant wording. The primary action and formats are front-loaded, followed by the optional filter and use case. Every sentence contributes essential information without fluff, making it efficient and easy for an agent to parse quickly.

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 read-only export tool with no output schema, the description covers the core purpose, formats, time filtering, and the explicit intent requirement. It does not describe the exact return structure, but the formats imply the output shape, and annotations cover the safety profile. Minor gaps like pagination or size limits are absent, but they are not critical for a dump operation. Overall, it is sufficiently complete 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 description coverage is 100%, so all parameters are already well-documented in the input schema. The description adds a high-level summary of the time window and formats, but these are already captured in the property descriptions. With full schema coverage, the baseline is 3, and the description does not introduce new parameter semantics beyond what the schema provides.

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 dumps the memory store in three specific formats (JSON, JSONL, Markdown) and supports optional time filtering. This distinguishes it from sibling tools like memory_get or memory_list, which are retrieval-focused, by emphasizing export for backup/inspection. The verb 'dump' and resource are explicit 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 specifies the intended use case ('Use for backup/inspection') which gives clear context for when to invoke it. However, it does not explicitly mention alternatives or exclusion criteria (e.g., when to use memory_list instead), leaving some room for inference. The guidance is sufficient but not exhaustive.

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?

Annotations already declare destructiveHint=true, idempotentHint=true, and readOnlyHint=false. The description adds valuable context beyond annotations: it specifies idempotent behavior (returns existed=false if key absent) and the explicit_user_intent requirement. No contradiction with annotations.

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, well-structured sentence that front-loads the primary action, then states idempotency and the intent requirement. Every word earns its place with no redundancy or 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?

For a simple tool with two parameters, annotations covering destructive/idempotent behavior, and no output schema, the description is complete. It explains the return behavior (existed=false) and the prerequisite (explicit intent), which are the key facts an agent needs. Nothing critical is missing.

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 both parameters are already well-documented. The tool description does not add parameter-specific meaning beyond what the schema provides, only reiterates the explicit_user_intent requirement. This meets the baseline for full schema coverage but adds no extra 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 the action ('Delete a single key from memory') with a specific verb and resource. It distinguishes itself from sibling memory_forget_by_tag by explicitly focusing on a single key, and the parameter schema reinforces this.

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 clear context: it deletes a single key and requires explicit user intent. It does not explicitly mention when to use alternative tools like memory_forget_by_tag or memory_set, but the single-key focus makes the usage context clear. No exclusions are stated, but the intent requirement sets a boundary.

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?

Annotations already declare destructiveHint=true and idempotentHint=true. The description adds the return value (deleted_count) and the explicit_user_intent requirement, which is beyond the annotations and provides important operational context. It also clarifies the scope ('every entry') but does not over-explain given the existing safety annotations.

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 short sentences with no filler. The primary action is front-loaded, and the return value and intent requirement are placed immediately after, making it easy for an agent to parse quickly.

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 destructive tool with no output schema, the description is complete: it specifies what is deleted, what is returned, and the required intent flag. No missing information would prevent an agent from invoking 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 100%, so the schema already documents both parameters with detailed descriptions. The description only restates the tag as 'every entry carrying the given tag' and repeats the intent requirement, adding no new semantic 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 states a clear verb ('Delete'), a precise resource ('every entry carrying the given tag'), and the return value. This distinguishes it from sibling tools like memory_forget (single-entry) and memory_set, leaving no ambiguity about what the 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 implies bulk deletion by tag and requires explicit_user_intent, but it does not explicitly contrast with alternatives such as memory_forget or memory_set. The usage context is implied rather than stated, so the agent must infer when this tool is the right choice.

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?

Annotations already declare readOnlyHint and idempotentHint, and the description adds useful context: it returns null for missing/expired entries and describes the effect of privacy_mode. This goes beyond the annotations without contradicting them.

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 concise sentences with the core purpose front-loaded. No redundant phrasing, and every sentence adds meaningful 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?

For a simple key-lookup tool with a single required parameter and optional privacy mode, the description covers behavior, return contents, and edge cases (missing/expired). Nothing critical is missing 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 100%, so the baseline is 3. The description adds value by mentioning the return structure (timestamps, ttl, tags, metadata) and reinforces privacy_mode behavior, which is not fully captured in the schema. This merits a 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 'Exact key lookup' which specifies the verb and resource, distinguishing it from sibling tools like memory_list and memory_search. It also details what the tool returns (value plus timestamps, ttl, tags, metadata) and behavior on missing/expired keys.

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 'Exact key lookup' implies use when you have a specific key, and the mention of privacy_mode provides a conditional usage option. While it doesn't explicitly exclude alternatives like memory_search, the context is clear enough for an agent to decide when to use 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?

Beyond the readOnly and idempotent annotations, the description adds meaningful behavior: missing keys are omitted from results, the operation respects DELX_MEMORY_NAMESPACE, and the batch size is capped at 50. These are non-obvious details that materially affect how an agent interprets results.

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, information-dense sentences with no filler. The core operation is front-loaded, followed by the most behaviorally relevant details (omission and namespace). Every clause 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 read-only batch lookup with fully documented parameters and safety annotations, the description covers all essential invocation details: operation type, key limit, missing-key behavior, and namespace handling. The schema fills in privacy_mode semantics, so nothing an agent needs to call this correctly is missing.

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 the schema already fully documents both parameters. The description's 'max 50' and 'missing keys omitted' notes reinforce the keys parameter, and it adds the namespace context, but it does not add substantial new semantics beyond what the schema provides.

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 phrase ('Batch exact-key lookup') with an explicit resource and operation mode. It clearly distinguishes itself from siblings like memory_get (single lookup) and memory_search (non-exact search) by emphasizing exact-key batch semantics.

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 makes the usage context clear: use when performing exact-key batch lookups, with a hard limit of 50 keys. It does not explicitly name alternatives or exclusions, but 'exact-key' strongly implies this is not for fuzzy or list-based retrieval.

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?

Annotations already declare readOnlyHint, idempotentHint, and openWorldHint, covering safety and world assumptions. The description adds useful behavioral context: it is namespace-aware and can include optional values. No contradictions with annotations.

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 with no filler. It front-loads the return payload, then states the intended use case, then adds the namespace-aware behavior. 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?

For a two-parameter, read-only, idempotent tool with fully described schema properties, the description covers what it returns, when to use it, and its namespace behavior. It does not detail the shape of the 'stats', but no output schema exists and the tool is low-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 description coverage is 100%, so the baseline of 3 applies. The description's mention of 'optional values' loosely maps to include_values but adds no meaning beyond the schema's own parameter 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 uses a specific verb ('Returns') and a clear resource ('store stats + the most recently updated keys'), and it differentiates itself from siblings by positioning this as a consolidated session-start call rather than a stats+list+get fan-out.

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 use the tool ('Designed for session start') and why it is preferable ('one call instead of stats+list+get fan-out'). However, it does not explicitly list exclusion cases or name the alternative sibling tools, so it stops short of full routing 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?

Annotations already declare readOnlyHint and idempotentHint, so the description carries the burden of explaining return behavior. The claim 'Returns keys + timestamps + tags only' contradicts the schema's privacy_mode parameter, which can return full entries in structured/raw modes. This misleading simplification is a significant transparency gap.

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 wasted words. The core purpose and routing to memory_get are front-loaded, and the namespace scoping is a useful one-line addition.

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 primary use case and points to the right sibling for values, but it omits any explanation of the privacy_mode parameter, which is central to the tool's output behavior. Combined with the misleading return statement, the description is incomplete for a tool with five parameters.

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 the description adds little beyond what the schema already explains. The only added context (filters and return payload) is partially misleading because it ignores the privacy_mode parameter and misrepresents the default behavior. The description does not clarify how privacy_mode affects output, leaving agents with incorrect expectations.

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 lists keys with optional filters (prefix, tag, since) and explicitly differentiates itself from memory_get by noting it returns only keys, timestamps, and tags, not values. This is a specific verb+resource with clear scope and sibling distinction.

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 instructs to call memory_get for values, which is a clear alternative for a common use case. However, it does not mention other siblings like memory_search or memory_stats, so guidance on when to use this vs. those is absent.

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 goes well beyond the readOnlyHint/idempotentHint annotations by disclosing bm25 ranking, key weighting, stemming, diacritic folding, prefix matching, case-insensitivity, LIKE fallback, snippet return, and privacy_mode snippet omission. This gives the agent an unusually complete behavioral model.

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?

Four information-dense sentences, front-loaded with the core action and then expanding into matching behavior, fallback, return shape, and privacy behavior. Every clause adds operational value; 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 search tool with no output schema, the description covers query semantics, ranking, matching edge cases, fallback behavior, result truncation, snippet presence, and privacy-mode effects. An agent has everything it needs to select and invoke the tool 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 100%, so the baseline is 3, but the description adds meaningful semantics: key-weighted relevance, prefix/diacritic matching, top-N snippet return, and privacy_mode=summary omitting snippets. It also clarifies how query text is interpreted beyond the schema's simple 'matched against keys and values' note.

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 'Full-text search across keys, values AND tags', naming the specific verb, resource, and scope. This clearly distinguishes it from siblings like memory_get (exact retrieval) and memory_list (enumeration).

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 fuzzy, partial, or accent-insensitive search queries through its matching details, but it never explicitly states when to choose this over memory_get, memory_list, or memory_get_many. It provides clear context but no exclusions or alternative routing.

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?

Annotations already signal a mutating, idempotent write; the description adds useful behavior beyond that: credential-shaped keys/values are rejected, explicit user intent is mandatory, and the return value indicates created vs updated. No contradiction with annotations.

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?

Four short sentences, each carrying distinct information: purpose, rejection rule, intent requirement, and return value. There is no filler 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 tool with six parameters, the schema is rich and the annotations cover safety/idempotency; the description fills the main remaining gap by stating the return behavior since there is no output schema. It could have mentioned TTL/tag/metadata behavior, but those are already fully documented in the 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 description coverage is 100%, so the baseline is 3; the description does not add parameter meaning beyond the schema. It mentions key, value, and explicit_user_intent only in passing, while tags, ttl_seconds, and metadata are left entirely to 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 opens with a clear verb and resource: 'Create or update a key in memory.' It is specific enough to identify the operation, though it does not explicitly differentiate from the sibling memory_set_batch or other memory tools.

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 a clear precondition: explicit_user_intent must be true, and the schema reinforces that it applies only when the user explicitly asks to modify memory. It does not name alternatives or state when not to use this tool instead of memory_set_batch, but the intent requirement supplies clear usage 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?

Annotations already mark the tool as idempotent and non-destructive. The description adds genuinely useful behavioral context: secret-shaped keys/values are rejected, namespace awareness, and that a single explicit_user_intent covers the entire batch. This goes beyond the structured fields and enriches the agent's mental model without contradiction.

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, zero filler. The most important information (upsert, batch size, transaction) is front-loaded, and each clause earns its place by adding a distinct constraint or behavior.

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 batch mechanics, transaction semantics, intent requirement, secret handling, and namespace scope. It doesn't describe the return value or error cases, but given the lack of an output schema and the richness of the input schema and annotations, the description is sufficiently complete for an agent 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 description coverage is 100%, so the schema already documents both parameters. The description adds value by clarifying that 'entries' is a batch upsert in one transaction and that 'explicit_user_intent' is batch-scoped, plus the secret-detection rule affecting values and metadata. These clarifications go 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 opens with a specific verb-resource pair ('Upsert up to 50 entries') and adds critical scoping details: the batch limit, atomic transaction, a single intent covering the batch, secret-shape rejection, and namespace awareness. It clearly distinguishes this from the single-entry sibling memory_set and other memory tools.

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 batch use and atomicity, and the sibling list makes the contrast with memory_set obvious, but it never explicitly states when to prefer this over alternatives (e.g., 'use when you need to write multiple entries atomically'). It also doesn't mention any exclusions or prerequisites.

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?

Annotations already declare readOnlyHint=true and idempotentHint=true, so the description's 'Safe to call' aligns with that without adding new safety info. The description adds context about the outcome (size category) but does not describe return format, granularity, or edge cases. Given the annotations cover the safety profile, a 3 is appropriate.

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, tightly written sentence that leads with the core purpose and then adds the key usage guidance. There is zero wasted wording, and the most important information (what it does and when to use it) 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 simple tool with one optional parameter and no output schema, the description covers the essential points: what it provides (high-level stats) and a canonical use case (first call). It does not explicitly differentiate from memory_data_inventory or memory_capabilities, but the size-assessment focus is enough for most agents to select it correctly. A mention of output shape or a contrast with siblings would make it more 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?

The input schema fully documents the privacy_mode parameter with a detailed description covering all enum values and their behavior. The tool description itself does not mention the parameter, but the schema provides 100% coverage, so the baseline of 3 applies. No additional meaning is added by 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 states the tool provides 'high-level stats about the local memory store' and clarifies its purpose to gauge store size ('empty, small, or large'). This is clear and specific, though it lacks an explicit verb like 'retrieve' or 'get'. It does not explicitly contrast with siblings like memory_data_inventory or memory_capabilities, which could be confused, but the size-gauge focus gives a distinct angle.

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 a clear when-to-use instruction: 'Safe to call first on every session to gauge whether the store is empty, small, or large.' This provides a concrete use case. It does not mention when not to use it or name alternatives, but the guidance is actionable and distinguishes it as an initial assessment tool.

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