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

The annotations include readOnlyHint and idempotentHint, signaling no side effects. The description aligns with 'Get', and listing the returned fields provides transparent expectations about the output.

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 brief and focused, using one concise sentence to convey the essential action and returned fields without redundant wording.

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 simple input schema and annotations, the description is sufficient. It specifies the resource, the identifier, and the set of fields returned, covering all necessary operational context.

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 single parameter 'id' has a clear description: 'ActionCard id (from card_list)'. This directly explains its meaning and source, achieving full schema coverage.

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

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

The description clearly states the tool's purpose: 'Get a single ActionCard by id' with a specific verb and resource. It also lists the full fields returned, making it distinct from a simple list operation.

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 explicit guidance is given on when to use this tool versus alternatives like card_list or other sibling tools. The description only explains what it does, not the appropriate context or conditions for selection.

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 main behavioral aspects. The description adds context about the unified status semantics (pending/accepted/dismissed/resolved) and the current/future sources, which is useful beyond the annotations but not critical.

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, directly to the point, with no redundant information. It efficiently communicates the tool's purpose, scope, and status semantics.

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 presence of an output schema and the readOnly/idempotent annotations, the description provides sufficient context: it explains the tool's cross-source nature, the unified status semantics, and the current source. No critical information 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?

The schema covers the only parameter (status) with 100% description coverage, including an enum. The description further clarifies that statuses use unified semantics, so the meaning of the parameter is fully explained.

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' and the resource 'ActionCards', and explicitly differentiates it as a cross-source, unified action inbox. This distinguishes it from sibling tools like suggest_list, which are source-specific.

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 when to use this tool (for a unified, cross-source list) versus source-specific alternatives, but it does not explicitly name alternatives or state conditions such as 'use this instead of suggest_list for a consolidated view'. Still, the cross-source and unified phrasing provides adequate 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?

Discloses side effects beyond the idempotentHint annotation: 'writes a correction memory and refreshes the persona.' This gives the agent a clear understanding of what happens on confirmation.

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 convey purpose, source, and effects without extraneous detail. Well-structured 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 tool, the description is complete: it specifies the input source, the action, and the effects. No missing information that would prevent an agent from using 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 argument 'id' is well described both in the schema and the tool description as 'Correction ID (from memory_pending)'. Schema coverage is 100%, and the description reinforces the source.

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

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

States a specific action ('Confirm') on a specific resource ('pending behavior correction') and clearly describes the effects. Differentiates from sibling tools by referencing corrections.json and memory_pending entries.

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?

Provides context on when to use: for pending corrections from memory_extract rule mode, with ID from memory_pending. Does not explicitly contrast with correction_reject but implies it by focusing on confirmation.

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 identify this as destructive and idempotent, and the description's 'reject' is consistent with that. The description adds context about why a correction might be rejected but does not describe the mechanism or postcondition of rejection, such as whether the entry is removed or marked.

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

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

One concise sentence with a helpful parenthetical and a direct instruction about where to find the ID. There is no redundant information or vague filler.

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 one-parameter action with an output schema present and safety annotations supplied, the description is sufficient to determine when and how to invoke it. It lacks only a formal statement of what rejection means, but annotations cover the destructive nature.

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 single id parameter has a description in the schema ('Correction ID (from memory_pending)'), and the tool description repeats this provenance. With full schema coverage, the description adds no additional parameter-level meaning, 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?

Clearly states the action ('reject') and the target ('a pending behavior correction'), with explicit rationale for when rejection is appropriate. The ID source is specified, and the name plus 'behavior correction' scope distinguishes it from sibling tools like correction_confirm and memory_reject.

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?

Gives actionable context by explaining that rejected corrections are those based on incorrect extraction or poisoned content and that the ID comes from memory_pending correction entries. It does not explicitly contrast it with correction_confirm, but the reject/confirm dichotomy is clear from the names and the stated rationale.

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 makes clear that the tool returns a template rather than directly performing memory operations, which matches the readOnly and idempotent annotations. It does not explicitly state that no state changes occur, but the 'returned template guides you through' wording conveys a non-destructive, planning-only role.

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 and well-structured, with two sentences covering purpose, output behavior, and usage context. Every sentence adds useful information without 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 tool with a simple optional date parameter and an output template, the description provides sufficient context: what it generates, which sub-tools are involved, and when to use it. The output schema is present, so return details need not be spelled out in prose.

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 only parameter, date, is fully documented in the schema with a default meaning. The description does not add significant extra semantics beyond that, but no required parameter details are missing.

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: generating a daily review guide that organizes work into memories and produces improvement suggestions. It also specifies the exact sub-tools the template guides through, making the intended function 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 says it is suitable at session end or on a daily schedule, providing clear usage context. It does not explicitly contrast with sibling tools, but the mention of the sub-tool flow and the 'daily review' purpose gives enough guidance for when to use it.

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 annotation already provides idempotency, and the description adds behavioral context by noting 'takes effect immediately, enters recall' and emphasizing content preservation (e.g., never drop negations). This goes beyond the annotation to inform the agent of expected side effects and storage behavior.

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 and front-loaded with the core action. It avoids unnecessary details and focuses on essential usage and content requirements, making it easy 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?

Given the tool's moderate complexity (4 parameters, 1 required, enums, output schema), the description provides sufficient context on when to call and what to store. It does not repeat parameter details already covered by the schema, and the output schema exists, so no further explanation is needed.

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 all four parameters (type, scope, content, priority). The description does not add extra parameter-level semantics beyond what the 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 clearly states the action (store a long-term memory) and the resource (memory), and explicitly distinguishes when to call it from other memory tools by specifying user statements like '以后X' or '我喜欢X'. This makes it unambiguous for an agent to know its primary purpose.

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 explicit 'when' conditions (call immediately on explicit preferences/facts/decisions/corrections) and adds a practical tip (don't wait for wrap-up). It does not explicitly mention alternatives or when-not-to-use, but the strong conditional guidance effectively directs usage.

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 annotation only includes idempotentHint, but the description discloses additional behavioral details such as entering recall and refreshing the persona for correction/preference types, offering transparency beyond the minimal annotation.

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, with two sentences: the first states the primary action and side effects, the second gives the usage condition. It is front-loaded and avoids unnecessary detail.

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, the description provides sufficient context: what it does, when to use it, and relevant side effects. No output schema is needed, and the description is complete for an agent to invoke 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 provides full coverage for the single parameter 'id' with a clear description ('Memory ID (from memory_pending)'). The tool description does not add extra meaning, so a 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 clearly states the tool's function: confirming a pending memory. It also specifies additional effects (enters recall, refreshes persona for certain types), distinguishing it from related tools like memory_reject and memory_pending.

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 states when to use the tool: 'Call when the user approves an item listed by memory_pending.' This provides clear guidance and indirectly distinguishes it from memory_reject.

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 discloses key behavioral aspects: extracted items default to pending (anti-poisoning), fallback to rule mode without external calls, and idempotence is implied by the annotation. No contradictions with the idempotentHint annotation.

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, using two sentences to cover functionality, usage timing, and default behavior. It avoids unnecessary fluff while retaining all essential information, making it 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?

Given the full schema coverage and the presence of an output schema (not shown but indicated), the description provides sufficient context for correct invocation. It includes when to call, fallback handling, and default state, leaving no critical gaps.

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?

All three parameters (scope, messages, sessionId) have descriptive metadata in the schema. The description also explains the default scope and the chronological nature of messages, enhancing understanding beyond the schema alone.

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: feeding recent conversation messages to the engine for automatic memory extraction. It distinguishes modes (LLM or rule) and is unambiguous about its purpose relative to other memory-related 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?

Explicitly provides when to call the tool (at conversation wrap-up or when enough dialogue accumulates) and instructs not to wait for a host hook. It also mentions fallback behavior to rule mode when LLM is unavailable, giving clear operational 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?

The annotations already declare readOnlyHint and idempotentHint, so the description need not repeat them. It adds valuable context about anti-poisoning and the requirement for user confirmation, which is additional behavioral guidance beyond the annotations and helps the agent understand the safety implications.

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, uses a clear numbered list for the two types, and includes a direct trigger instruction. No unnecessary fluff, and the structure aids readability.

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 provides enough context to call the tool correctly: when to call it, what it lists, and how to handle the results. It also mentions the anti-poisoning rule. Since an output schema exists (though not shown), explaining return values is not required. The tool is fully specified for an agent to use.

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?

There are no parameters, so the schema fully covers them. The description adds no parameter details (irrelevant here). Baseline score for zero parameters is 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 the tool lists automatically extracted but unconfirmed items, and distinguishes two types (memories and corrections) with explicit handling tools. This is a specific verb ('list') and specific resource ('pending memories & corrections'), and it differentiates from siblings like memory_recall by emphasizing the unconfirmed nature.

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 says to call after memory_extract/memory_capture and provides the exact follow-up tools (memory_confirm/reject, correction_confirm/reject). It also warns against using this for recall until confirmation, which clarifies when not to use it and when to use alternatives like memory_recall.

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 indicate readOnlyHint and idempotentHint, and the description confirms a read-only search operation with no side effects. The fallback behavior for embedding unavailability is also disclosed, adding transparency.

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-loads the core purpose, and efficiently includes usage timing and return details without redundancy. It avoids unnecessary filler while still being informative.

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 output schema, annotations, and complete parameter descriptions, the description provides enough context for an agent to invoke the tool correctly. It includes return contents, filtering options, and usage scenarios.

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?

All four parameters are described in the schema with clear meanings: query as the search keyword/question, type as a filter, limit as max results with default, and scope as read scope with auto/project/global options. Coverage is 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 clearly states the tool searches long-term memories by keywords and returns matching entries with type, importance, and similarity. The purpose is immediately obvious 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?

Explicit guidance is provided: call at the start of a new session/task to restore context, and call whenever the user references past work, project history, or personal preferences. This leaves no doubt about when to use the 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?

The annotation already includes destructiveHint and idempotentHint, and the description adds context by specifying the scope (pending memory) and the rationale. No contradictions are present.

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, information-dense sentence with no superfluous words. All key elements are present.

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

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

The tool is simple: one parameter, no output schema, and annotations. The description fully covers what it does, when to use it, and what parameter to provide. Nothing essential 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?

The only parameter 'id' is described as 'Memory ID (from memory_pending)', which precisely indicates what value to supply and where it originates. Full schema coverage is achieved.

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 (reject and delete) and the target (a pending memory), plus the specific reasons (incorrect extraction or poisoned content). It is immediately obvious 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 explicitly specifies when to use the tool: for pending memories that were incorrectly extracted or contain poisoned content. This gives clear guidance without needing to inspect sibling tools.

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

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

The annotation declares readOnlyHint and idempotentHint, which aligns with the description's 'View' action. The description does not add extra context beyond what the annotations provide, but it is consistent and sufficient for a read-only operation.

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, concise sentence that directly conveys the purpose without unnecessary words. It is well-structured and easy to understand.

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 lists the kinds of statistics available, which gives a good sense of what to expect. However, it does not specify the exact output format or whether the result is a single object or a list, but this is a minor gap given the simplicity of the tool.

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

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

The input schema is empty, meaning there are no parameters to describe. The description does not need to add parameter details, so this dimension is fully satisfied by 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 action (View) and the resource (memory system statistics), and lists specific kinds of statistics provided (atom count, type distribution, pending items, persona status). This is unambiguous and does not require additional context.

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

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

The description implies this tool is for viewing memory statistics, but it does not explicitly state when to use it over alternatives. No sibling tools are mentioned or contrasted, so the guidance is minimal but not misleading.

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?

ReadOnly and idempotent annotations already indicate safety; the description reinforces this by describing teaching rather than state changes. It does not add detail about side effects, but none are implied and the annotations cover it.

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?

Single concise sentence with clear front-loaded purpose and a direct usage condition. No wasted words or redundant elaboration.

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 parameterless, read-only instructional tool with an output schema, the description fully explains its content and invocation timing. Nothing essential 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?

With zero parameters, there is nothing to document. The description appropriately focuses on what the guide covers and when to invoke it, matching the baseline expectation for a parameterless tool.

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?

Clearly states it is a cold-start guide that teaches how to use ProactiveAgent memory and suggestion tools, distinguishing it from the actual tool siblings by framing it as instructional orientation rather than a data operation.

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 instructs to call once on first mount in a new environment or project, giving a precise condition for use and implying it is not needed for routine operations.

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 aligns by saying 'Read' and 'Returns'. The description adds useful behavior detail about the merged view and per-line scope, going 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?

The description is two sentences with no fluff. It packs purpose, usage timing, and return behavior into a compact, readable format. 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?

Given the annotations and schema, the description is complete. It covers what the tool does, when to use it, and what it returns. No critical information is missing for an agent to invoke 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 only parameter 'scope' has a full enum with descriptions, and the description explains the default behavior ('merged view by default') and what merging means (global base persona + current project overrides). This adds meaningful context to the schema definition.

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 reads the L3 user persona markdown, a stable summary of preferences, and distinguishes it from writing tools like persona_save. The verb 'Read' and the specific resource 'L3 user persona markdown' make 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?

Explicitly provides when-to-use guidance: 'Call at the start of a new session to load the user profile and preferences.' This is concrete and actionable, and the read-only nature implicitly contrasts with writing tools like persona_save.

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?

Discloses that saving overwrites the relevant part of the merged view and clarifies the project vs global behavior. The idempotentHint annotation is consistent with the overwrite semantics.

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 compact, directly relevant, and front-loads the core action. No redundant or filler wording is present.

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

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

Provides enough context for correct invocation, including the critical default-scope behavior and the purpose of the tool. No significant missing details are apparent.

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 already describes content and scope, and the description adds meaningful context about the default scope and its merged-view effect. This goes beyond the basic parameter descriptions without being excessive.

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?

Clearly states the tool saves or overwrites persona markdown, distinguishing it from persona_get. The description also explains the two scopes and their effect, 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?

Explains that it defaults to the current project layer and that global writes the base persona, with a stated use case of maintaining the persona or project-specific rules. It does not explicitly contrast with sibling tools, but the context is clear enough for selection.

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's 'Read' aligns with the readOnlyHint annotation. It adds context about the tool's intended role as a proactivity signal, which goes beyond the bare annotations, but it does not detail side effects or error behavior. Since annotations already cover the key behavioral aspects, 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?

The description is concise and well-structured: it leads with the core action, then provides the contextual purpose in a parenthetical. Every word adds value, and the length is appropriate for the tool's simplicity.

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 read-only tool with one parameter and no complex output schema (though output schema is flagged as present, it is not detailed), the description sufficiently conveys its function and purpose. It could clarify what constitutes a 'hot scene' but the intent is clear enough.

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 only parameter 'limit' is fully described in the schema (default 3, min 1, max 10), and the description does not add extra meaning beyond what the schema provides. With 100% schema coverage, 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 clearly states the action ('Read') and the resource ('recent hot-scene summaries'), and adds context about being a timing signal for proactivity. This makes the tool's purpose distinct and easily distinguishable from sibling tools like card_list or memory_recall.

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

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

The description explains when to use the tool ('timing signal for proactivity: what is being worked on recently, how hot'), providing clear context. However, it does not explicitly mention when not to use it or compare to alternatives, so it falls short of a 5.

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

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

The description discloses side effects: for memory_correction it writes a behavior correction and refreshes the persona, and for automation/todo it attempts creation or returns executable instructions. The idempotentHint annotation is not contradicted. No hidden behaviors.

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 moderately concise, containing three sentences that pack essential details without excessive fluff. It is structured logically by type, which aids readability.

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 presence of sibling tools, the description sufficiently differentiates suggest_accept by explaining the accept action and its consequences. It covers the main branches of behavior and mentions the output fallback, making it complete for a tool of this 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?

The schema already provides clear descriptions for id and host, and the tool description reinforces the source of id and lists example host names. While the description does not add much beyond the schema, it is consistent and clear.

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: 'Accept a suggestion' and explicitly distinguishes between memory_correction and automation/todo types with specific actions for each. The verb and resource are 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 what happens for each suggestion type and notes the host requirement for fallback wording. It implies when to use this tool but does not explicitly contrast it with sibling tools like suggest_ignore or suggest_list, which could enhance 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 only declare idempotentHint, so the description carries the burden of revealing additional behavior. It explains that ignoring counts toward frequency learning and that repeated ignores auto-silence that type, which is valuable context beyond idempotency. 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?

A single, front-loaded sentence with the core action first and behavioral details in parentheses. 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?

With one parameter, an output schema, and idempotency annotation, the description covers the tool's effect and learning behavior. It does not mention potential error cases or preconditions, but these are minor for a simple ignore action.

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 parameter description already clarifies the source of the ID. The tool description does not add further meaning to the parameter, so the 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 states a specific verb ('Ignore') and resource ('suggestion'), and the parenthetical adds behavior that distinguishes it from siblings like suggest_accept and suggest_now. An agent can clearly identify 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 implies when to use it (when you want to ignore a suggestion) but does not explicitly contrast it with suggest_accept or state conditions for choosing it over alternatives. There is no when-not guidance, leaving some room for inference.

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 readOnlyHint and idempotentHint annotations already establish that the tool is non-destructive and side-effect-free. The description's 'list' phrasing is consistent with these hints and adds no new behavioral context, but the existing annotations cover transparency adequately.

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, concise sentence with no redundant phrases. It directly states the action, resource, and the optional filter, achieving maximum clarity with minimal 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 simple list operation with one optional parameter, the description is sufficient. The read-only nature is corroborated by annotations, and the tool's purpose is fully self-explanatory. No additional context is needed for an agent to use it effectively.

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 fully covers the only parameter (status) with an enum and description. The tool description reiterates the enum values, providing minimal additional context beyond the schema, which meets the baseline but does not elevate it further.

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 as listing suggestion records and explicitly mentions the filterable status, making its purpose unambiguous. It distinguishes itself from sibling tools like suggest_accept or suggest_now, which imply mutations, by focusing on the read-only 'list' action.

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 filtering guidance by enumerating the allowed status values (suggested/accepted/ignored/never), which helps the agent understand how to narrow results. However, it does not directly state when to prefer this tool over alternatives like suggest_accept or suggest_now, though the read-only nature is implied by the name and annotations.

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?

Description discloses that it returns 'newly created suggestions (may be empty)', implying a side effect, and the idempotentHint annotation helps clarify retry safety. It does not fully describe all state changes or error behavior, but the combination of description and annotation is fairly transparent.

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 compact and front-loads the core purpose and triggers. The phrase 'Core principle: silence is also a skill' is somewhat aphoristic but still adds meaningful usage guidance and does not feel like filler.

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 moderate complexity and the presence of sibling tools, the description covers the main entry conditions, output nature, and constraints. It could be slightly stronger by explicitly distinguishing when to use suggest_list/suggest_accept/suggest_ignore instead, but it is largely complete for an agent to decide when to call.

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 covers 100% of parameters, and the description adds useful semantic detail for trigger values (session_end default, session_mid realtime strong signals only, manual). It reinforces the messages and sessionId purposes without contradicting 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?

Clearly states the verb 'Evaluate' and the resource 'proactive suggestions', with explicit examples of signals (unfinished todo, repeated mistake, follow-up promised, automation opportunity). It is easy to distinguish from sibling tools like suggest_list or suggest_accept because it focuses on deciding when to create suggestions.

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?

Provides concrete call conditions: when conversation signals are present, plus explicit constraints such as 'At most 1 per call', 'session budget limits', and 'none during do-not-disturb hours'. The guidance 'silence is also a skill' adds useful judgment context for when not to suggest.

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