MemAI

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

No annotations exist. The description only states it records and stores as type='anti_pattern', with no disclosure of side effects, idempotency, permissions, or other behavioral traits.

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 with no extraneous content. It front-loads the core action.

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 5 undocumented parameters and no output schema, the description fails to provide sufficient context for the agent to correctly invoke the tool. It leaves parameter semantics and return behavior unclear.

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 0% schema coverage, the description adds no information about the 5 parameters (pattern, why_wrong, instead, domain, session). The agent must rely solely on parameter names, which are insufficient.

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 records a mistake/temptation and the correct approach, and it mentions the stored type 'anti_pattern' and linkage to pulse(). This effectively communicates the purpose and distinguishes it from siblings like pulse.

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: record anti-patterns via this tool, retrieve them via pulse(). However, it does not explicitly state when to use this tool over alternatives or provide exclusions.

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

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

Discloses that data is stored as type='checkpoint', fields are free-length, and checkpoints are meant for bearing. However, it does not specify whether writing a checkpoint overwrites or creates a new entry, nor the role of optional parameters like domain and session. With no annotations, this is a minor 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?

Three concise sentences that front-load purpose, then provide usage guidelines and storage semantics. No redundant information; every sentence adds value.

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?

Covers main aspects: purpose, usage guidelines, parameter roles, and storage type. Missing details on optional parameters and persistence behavior (overwrite vs append) but adequate for a tool with no annotations or output schema. References to pulse() and note() provide useful 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 description lists the four required parameters and notes they are free-length and should be readable summaries. However, it does not explain the optional domain and session parameters, and schema description coverage is 0%. It partially compensates but leaves ambiguity about the optional fields.

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 as snapshotting current working state with specific fields (intent/established/pursuing/open_questions). It distinguishes itself from sibling tools like note() by emphasizing that checkpoints are for bearing, not archives, and references pulse() for reading.

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 advises when to use (summary for next session) and when not to (timeless detail into note()). It also explains the consumption mechanism via pulse(). This differentiates from siblings effectively.

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

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

With no annotations, the description carries full burden. It discloses method (semantic/lexical), exclusion of checkpoint pairs, and non-automatic nature. However, it does not explicitly state whether the tool is read-only or if it has side effects, leaving some ambiguity.

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 a clear opening sentence and uses dash-separated points for additional details. It is front-loaded and avoids verbose repetition, though could be slightly more 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?

The description covers core purpose, method, and exclusions, but lacks parameter explanations. Given 0% schema coverage and 4 parameters, the description is incomplete. However, it does mention output includes method and score, which is useful.

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%, and the description does not explicitly explain any of the four parameters (type, limit, domain, threshold). It only implies threshold via similarity score mention. This is insufficient for an agent to know how to set these parameters.

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 surfaces likely-duplicate/contradictory memory pairs, explains the method (semantic vs lexical), and notes exclusions. It distinguishes itself from sibling tools like link_memories, edit_memory, and forget by clarifying it is not an automatic merge.

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 the tool returns candidate pairs for review, not an automatic merge, and mentions subsequent tools (link_memories, edit_memory, forget). It provides context on when checkpoint pairs are excluded and method selection, but does not explicitly state when not 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?

With no annotations, the description discloses that old content is preserved in edit history, but fails to mention required permissions, reversibility, or any side effects of the update, providing only partial behavioral clarity.

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 the first sentence delivering the core purpose concisely. It is front-loaded and efficient, though it could briefly mention key parameters without losing conciseness.

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 has 3 parameters, no output schema, and no annotations, the description lacks parameter descriptions and return value explanation, leaving significant gaps for an agent to use the tool confidently.

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%, and the description adds no information about the parameters (uid, new_content, note), forcing agents to rely solely on parameter names without any additional context or examples.

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 'Correct/update a memory's content' with a specific verb and resource, and distinguishes from siblings like 'forget' (delete) and 'set_confidence' (modify confidence) by emphasizing preserving edit history.

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 use for corrections while preserving history, but does not explicitly state when not to use this tool versus alternatives like 'forget' or 'purge_memory', leaving the agent to infer 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?

No annotations are provided, so the description fully carries the burden. It discloses that content is kept, embeddings are not recomputed, and a reason is recorded as an audit entry. It does not mention reversibility or side effects, but for a soft-delete action, the disclosed behaviors are sufficient.

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

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

Two concise sentences with no wasted words. The first sentence states the core purpose, and the second adds behavioral detail. Front-loaded and 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?

The description is mostly complete for a simple tool given no output schema. It explains the key behavior and the `reason` parameter, but lacks explanation for `superseded_by` and could benefit from explicit usage context vs sibling tools. Still, adequate.

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 0% (no parameter descriptions), so the description must compensate. It explains the `reason` parameter (audit entry) and implies `uid` is the memory identifier, but does not explain `superseded_by`. This partial coverage earns a 4, as it adds meaning beyond the schema.

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

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

The description clearly states the tool archives a memory via soft delete, keeping content but excluding from default search/list. It also notes recording a reason as audit entry, providing a specific verb (archive) and resource (memory) that distinguishes it from siblings like purge_memory.

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 (when you want to exclude from results but retain data) by contrasting soft delete with default search/list behavior. However, it does not explicitly compare to sibling tools like purge_memory or set_confidence, and lacks when-not-to-use 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?

No annotations provided, so description must disclose behavioral traits. It describes output contents but omits safety guarantees (e.g., read-only, no side effects) and any error conditions.

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 efficient sentence with key elements front-loaded. Could add minor context without inflation.

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?

Adequately covers the tool's purpose and main output features but lacks details on exact return structure or edge cases; no output schema exists to compensate.

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%, and the description does not explain the uid parameter beyond its role as an identifier; missing format instructions or origin guidance.

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

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

Description clearly states the verb 'fetch', resource 'memory', and specifies inclusion of edit history and relations, distinguishing it from siblings like get_relations and 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?

No explicit guidance on when to use this tool versus other retrieval siblings (recall, search, list_by_domain). The intended use case is implied but not clarified.

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

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

With no annotations provided, the description bears full responsibility for behavioral disclosure. It accurately states that the tool lists both incoming and outgoing relations, implying a read-only operation. However, it omits potential details like pagination or ordering, but for a simple list tool this is adequate.

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 of 8 words with no filler or redundancy. It is front-loaded with the action and resource, 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 simplicity (one parameter), and the existence of an output schema documenting return values, the description sufficiently covers its purpose. It clearly states what is listed (incoming and outgoing relations) and for which memory, meeting completeness needs.

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

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

Schema description coverage is 0%, so the description must compensate. It indicates that 'uid' is the unique identifier of a memory, adding basic context. However, it does not specify the expected format of the UID (e.g., UUID or string pattern), leaving some ambiguity.

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 'list' and specifies the resource 'relations (incoming and outgoing) for a memory'. It clearly distinguishes from siblings like 'get_memory' (gets a single memory) and 'link_memories' (creates relations).

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 states it lists all relations for a memory, but provides no guidance on when to use it over alternatives like 'search' or 'list_by_domain'. No explicit when-not-to-use or prerequisites are mentioned.

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

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

No annotations are provided, so the description carries the full burden. It discloses that notes are stored as type 'handoff' and that pulse() retrieves open ones, but does not discuss auth, rate limits, or side effects.

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: the first states the primary purpose, the second adds storage and retrieval details. No unnecessary words.

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

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

Given 3 parameters, no output schema, and no annotations, the description covers the core functionality but lacks details on return values, parameter dependencies, and edge cases.

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 0% schema description coverage, the description must add meaning. It hints at 'domain' and 'session' via the second sentence, but does not fully explain each parameter's purpose or default behavior.

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

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

The description clearly states the action ('leave a note') and the resource ('for another agent/session picking up this work'). It also distinguishes from siblings like 'note' by specifying the handoff context and storage type.

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 context (handing off work) but does not explicitly state when to use this tool versus alternatives such as 'note' or 'checkpoint'. No exclusions or when-not cases are mentioned.

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?

Although no annotations are provided, the description adds important behavioral context: the docs are extracted live from code docstrings at call time, ensuring accuracy and preventing drift. This is a unique trait not otherwise disclosed. The description does not mention side effects or auth, but for a read-only help tool, 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 four sentences long, each serving a purpose: stating the tool's role, explaining the two usage modes, and highlighting the benefit of live extraction. No information is redundant or extraneous, and the structure is front-loaded with the core purpose.

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

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

Given the tool's simplicity (one optional parameter, no output schema), the description covers the essential usage and behavioral aspects. It does not explicitly state the output format (likely plain text or markdown), but this is a minor gap. Overall, it is reasonably complete for a help 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 has one parameter 'command' with no description and 0% coverage. The description compensates by explaining its purpose: without arguments returns summaries of all tools, with 'command=<name>' returns that tool's full docstring. This fully defines the parameter's semantics.

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: to explain memai tools by reading their code docstrings. It distinguishes two modes of operation (with and without arguments), making the tool's function specific and different from sibling tools which are the actual tools being explained.

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 guidance on when to use the tool with and without the 'command' argument. While it does not mention when not to use it, the context of a help tool makes that unnecessary. The absence of alternatives is acceptable since this is a meta-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?

No annotations provided. Description discloses it creates an edge and is queryable, but does not cover side effects, permissions, or mutation nature beyond what is implied.

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 efficient sentences with no wasted words. Front-loads the primary action.

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 4 parameters (3 required), no output schema, and no annotations, the description covers only the core action and one parameter. Missing explanation of UIDs and note, making it incomplete for reliable 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?

Schema coverage is 0%. Description only adds meaning for 'relation_type' with examples; 'from_uid', 'to_uid', and 'note' are left entirely to schema titles, which lack 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 clearly states the tool creates a queryable edge between two memories, using specific verb and resource. It distinguishes from siblings like 'get_relations' and 'edit_memory'.

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 example relation types and advises consistency, but lacks explicit guidance on when to use vs alternatives 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?

Discloses key behaviors: exact domain matching, snippet truncation, and ordering by recency. Since no annotations are provided, the description adequately covers behavioral traits.

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, front-loaded with the main purpose. Every sentence serves a purpose, though could be slightly more 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?

Given the presence of an output schema, the description covers usage context, ordering, truncation behavior, and fallback role. Missing parameter info for 'type' is the only notable gap.

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?

Description explains domain as exact match and implies limit controls count, but completely omits the 'type' parameter. With 0% schema description coverage, it adds some value but leaves a gap.

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 lists active memories for a domain, sorted most recent first. Also explicitly differentiates from sibling search by calling itself a fallback when search misses.

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 clear context: use as fallback when search fails, and advises to consult list_domains for exact domain strings. However, it doesn't explicitly mention when not 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?

Given no annotations, the description adds behavioral context: domain drift over time, exact matching by siblings, and ordering by most recent activity. It does not discuss side effects or permissions, but as a read-only list tool, this is adequate. The output schema exists to cover return values.

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 5 sentences, each adding value. It is front-loaded with the core purpose and provides necessary context. Could be slightly more streamlined, but overall 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 zero-parameter tool with an output schema, the description covers purpose, use case, and ordering. It lacks detail on authentication or potential empty results, but these are minor. Overall, it is complete enough for effective 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, and schema coverage is 100%. The description adds meaning by explaining what the list contains (distinct domains with memory count and latest activity), which is valuable beyond the empty 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 'List distinct domains with their memory count and latest activity', specifying the verb and resource. It distinguishes itself from siblings by explaining its role in warm-up discovery to get exact domain strings that pulse and list_by_domain match exactly.

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 advises using this tool for warm-up discovery before using pulse or list_by_domain, which require exact matching. It tells when to use the tool and implies alternatives, providing clear 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?

With no annotations, description defines behavior (lists active memories, snippet-truncated). However, it does not disclose potential side effects, rate limits, or authentication needs, leaving gaps for an agent.

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 front-load the purpose and provide a key behavior note. No unnecessary words.

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

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

Given three optional parameters, no annotations, and no sibling differentiation, the description is functional but lacks details on 'active' semantics, default behavior, and how results are ordered. Output schema exists, so return structure is covered.

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

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

Schema coverage is 0%, so description adds value by explaining optional filtering by type/domain. However, it does not define valid values or mention the limit parameter, so meaning is incomplete.

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?

Describes listing recent active memories with optional filters. While clear, it doesn't explicitly differentiate from sibling 'list_by_domain', which may also filter by domain but without recency emphasis.

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?

Mentions snippet truncation and points to get_memory for full records, but lacks explicit guidance on when to use this tool over siblings (e.g., list_by_domain) 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?

No annotations are provided. The description discloses that tags feed both keyword index and embedding, and that memories are retrieved by relevance. However, it does not mention whether saving overwrites existing notes, authorization needs, or side effects, leaving gaps in behavioral 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 brief, uses bullet points effectively for tags, and front-loads the main purpose. Every sentence adds value without unnecessary words.

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

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

With no annotations, no output schema, and 0% schema description coverage, the description should provide comprehensive context. It explains tags and retrieval but omits details on domain and session parameters, return values, error scenarios, or creation vs. update behavior, leaving the tool incompletely documented.

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%. The description explains the 'tags' parameter in detail (comma-separated keywords, feeds indexing and embedding) and implies that 'content' is the memory content. But 'domain' and 'session' parameters are not explained, so the description adds partial 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 'Save a general long-term memory (fact, decision, finding). Stored as type='note'.' This specifies the action and resource, and implicitly differentiates from retrieval siblings like recall and search, but does not explicitly contrast with other memory-saving 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 explains retrieval using recall(), search(), and pulse(), but does not provide explicit guidance on when to use this tool versus siblings like anti_pattern, checkpoint, or reasoning. The usage context is implied rather than clearly stated.

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

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

Despite no annotations, the description fully discloses read-only nature, the counts, note, and safety-backup path, and the workflow division. Could be 5 but lacks explicit mention of no side effects beyond read.

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 paragraphs with front-loaded purpose and concise supplementary context. Slightly wordy but every sentence adds value; no 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?

The description fully covers purpose, usage timing, output contents, and relationship to sibling tool, leaving no gaps for this simple list tool with no 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?

With zero parameters and 100% schema coverage, baseline is 4. The description adds value by explaining the output fields (counts, note, backup path) which enriches understanding beyond the empty schema.

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

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

The description clearly states the verb 'List' and the resource 'optimization runs', and distinguishes itself from optimize_stage by specifying it's a read-only companion for post-staging review.

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 says 'after staging, use this to see whether the user has applied/rejected your suggestions in the admin dashboard' and clarifies that applying/rejecting stays in the dashboard, effectively guiding when and when not to use.

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

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

No annotations are provided, so the description bears full responsibility. It thoroughly discloses behavioral traits: compact format, truncation logic, 'truncated' flag, pagination, omission of empty/default fields, precision drops, and constraints on output size. It also explains the content of the response (stats, domain_hints, anchors) and the verification workflow.

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 lengthy but well-organized, with clear sections for purpose, format, usage, parameters, and verification. Every sentence adds value, though it could be slightly more concise without losing information. The front-loading of the purpose is effective.

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 complexity (7 parameters, no output schema, many sibling tools), the description is exceptionally complete. It explains the full structure of the response, pagination behavior, and integrates workflow guidance. It even includes verification instructions for downstream actions, leaving no ambiguity.

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 0% coverage, but the description compensates by explaining the role of each parameter: 'full' for full bodies, 'since' for delta scans, 'domain' and 'type' for filtering, 'limit' and 'offset' for pagination. It provides concrete examples (e.g., ISO timestamp or date for 'since') and explains how parameters affect output.

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: 'Dump the memory corpus compactly so you can plan a curation pass.' It distinguishes this tool from siblings by positioning it as the first step in an 'optimize my memories' workflow and by specifying its unique output (memories, edges, dedup hints).

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 context on when to use this tool (step 1 of workflow) and when to use alternatives (e.g., fetching a single memory with get_memory). It advises on incremental curation vs full passes using the 'since' parameter. It does not explicitly list exclusions, but the context is well covered.

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

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

With no annotations, the description provides extensive behavioral details: suggestions are not applied here, backups are taken, changes are reversible, destructive suggestions require verification, invalid suggestions are reported. No contradictions.

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

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

The description is well-structured with clear sections and bullet points, but is somewhat verbose. Given the complexity of the tool, the length is justified, but there is some redundancy (e.g., repeated explanation of reversibility).

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?

Despite no output schema, the description explains the return structure (run_id, staged, errors). It covers workflow context, suggestion kinds, error handling, and behavioral guarantees, making it highly complete for the tool's complexity.

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

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

The description adds immense semantic value beyond the minimal schema (array of objects with additionalProperties). It fully specifies the structure of suggestion objects, including kinds, payloads, required fields, and examples. The 'note' parameter is not described, but the suggestions parameter is richly documented.

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: 'Stage a batch of curation suggestions for human review in the dashboard.' It specifies it's step 2 of a workflow and distinguishes it from siblings like optimize_scan and optimize_status by explaining the staging role.

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 the tool's role as part of a workflow ('Step 2 of the optimize my memories workflow'), but does not explicitly list alternatives or when not to use it. The context of sibling tools and the detailed kind descriptions indirectly guide 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?

With no annotations, the description carries the full burden. It declares read-only behavior and lists all returned fields (run header, suggestion details including decision status), giving good insight into what the tool provides without side effects.

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 front-loaded with the core purpose in the first sentence. The second sentence is informative but slightly verbose listing fields; could be more concise. No wasted words overall.

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 one parameter and no output schema, the description is adequate. It explains what the tool returns. However, it lacks context on how run_id is obtained, error handling for invalid IDs, and doesn't mention pagination or large runs, leaving some 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?

The only parameter, 'run_id', has no description in the schema (0% coverage). The tool description does not explain what run_id represents or how to obtain it (e.g., from optimize_runs), leaving the agent with minimal guidance beyond the integer type.

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 specific verb 'inspect' and the resource 'optimization run'. It distinguishes itself from siblings like 'optimize_runs' (lists runs) and 'optimize_scan' (scans) by focusing on a single run's details.

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 indicates this tool is for inspecting a single run in detail, providing context on its scope. However, it lacks explicit when-to-use vs alternatives, such as when you would use 'optimize_scan' instead.

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

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

With no annotations provided, the description carries full burden. It discloses that it picks checkpoint by created_at DESC, returns latest_checkpoint in full with relations, truncates other lists snippets, and recommends get_memory for full records. This is comprehensive behavioral disclosure.

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, well-structured with a clear introductory sentence followed by detailed explanation of behavior and caveats. Every sentence provides unique value, and it is appropriately sized.

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

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

Given no output schema and multiple return components (checkpoint, handoffs, anti-patterns, notes), the description explains the output well but omits the input parameter 'domain' entirely. This leaves a gap in completeness.

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 'domain' has 0% schema description coverage, but the description does not mention it at all. The description adds no meaning beyond the schema, leaving the agent guessing about the parameter's purpose or effect.

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: 'Session warm-up: latest checkpoint + open handoffs/anti-patterns + recent notes.' It uses a specific verb-resource combination with scope, and distinguishes from siblings like recall/search and get_memory.

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 states when to use pulse (session warm-up, to get latest checkpoint by created_at DESC) and when not ('similarity-ranked top-1 can return stale checkpoint'). It also provides alternatives: use recall/search for relevance-ranked recall, get_memory for full items.

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

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

No annotations are provided, so the description carries full burden. It discloses the destructive irreversible nature, the exact deletion scope, and the confirm_phrase requirement. However, it does not mention authorization needs or response format.

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 few sentences long, each adding value. It is well-structured with a warning and guidelines, though slightly verbose. 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 no output schema, no annotations, and only 2 parameters, the description is fairly complete. It covers purpose, usage, and parameter semantics. Missing information about return values or permissions, but still adequate for a simple 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?

Schema coverage is 0%, but the description adds critical meaning: it explains that confirm_phrase must exactly equal 'DELETE <uid>' and must come from the user's own message, and that uid identifies the memory. This partially compensates for the lack of schema 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 clearly states the tool permanently deletes a memory along with its edit history and relations, using specific verbs and resources. It distinguishes itself from the sibling 'forget' tool by highlighting irreversibility.

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 advises using 'forget' instead unless permanent removal is requested, and gives a strict guardrail for the confirm_phrase parameter, preventing the agent from constructing the confirmation string itself.

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

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

No annotations are provided, so the description must carry the full burden. It does not disclose behavioral traits such as whether the operation is destructive, requires permissions, or has rate limits. The description is minimal and lacks 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 consists of two short, front-loaded sentences that convey the core purpose efficiently. While it lacks depth, it is well-structured and free of redundancy, earning a high score for conciseness.

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 has 3 parameters, no output schema, and no annotations, the description is incomplete. It does not cover parameter usage, return values, or behavioral details. An agent would lack necessary context 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?

The input schema has 3 parameters (domain, content, session) with 0% description coverage. The tool description does not mention or explain any parameters, failing to add meaning beyond the schema. The description should compensate but does not.

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 'Record' and the resource 'a reasoning trace / analysis', distinguishing it from factual storage by explicitly noting it is a thought process, not a fact.

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 indicates when to use the tool (for thought processes) and how to retrieve the stored traces via filtering by type='reasoning'. It does not explicitly mention when not to use it or provide alternatives, but the distinction from siblings like 'note' is implied.

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

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

With no annotations, the description fully covers behavioral traits: hybrid search, scoping to type='note', relevance ranking, snippet-truncated output, and the need to call get_memory for full records. No contradictions.

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

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

The description is concise with three sentences, front-loaded with the primary purpose. Every sentence adds value without 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?

Given the complexity and presence of an output schema, the description adequately covers the tool's behavior, output format (snippet-truncated), and relationship to siblings. It provides sufficient context 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?

The description does not explicitly explain the individual parameters (query, limit, domain). While the purpose implies query is the search term, limit and domain are left unspecified. With 0% schema coverage, the description should compensate, but it largely omits parameter details.

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: recalling long-term knowledge saved with note(). It specifies the scope (type='note'), the search method (hybrid BM25 + vectors), and explicitly differentiates from sibling tools like search and get_memory.

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 provides guidelines on when to use this tool ('dedicated verb for bring back what I noted'), contrasts with search(type='note') as an alternative, and explains the recency behavior difference from checkpoints with pulse().

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

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

With no annotations, the description fully discloses behavior: result annotations (match_source, fts_rank, vec_distance), candidate widening, keyword OR-ing, default active-only, embedding fallback, and snippet truncation with reference to get_memory for full records.

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 front-loaded with the core purpose and efficiently covers multiple aspects. A minor consolidation of usage tips could be tighter, but overall effective with minimal 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?

Given the tool's complexity (hybrid search, multiple parameters, output schema exists), the description is comprehensive: covers result fields, fallback, type filters, default behavior, and sibling alternative. No gaps identified.

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

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

Schema coverage is 0%, but the description compensates fully: explains type values (note, reasoning, etc.), query behavior (paraphrases OR'd), domain as part of search scope, and mentions limit default implicitly. Adds value beyond 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 it performs hybrid search over memory content, tags, and domain using BM25 and vectors. It distinguishes from sibling recall by noting recall is sugar for search(type='note').

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 usage tips like multiple space-separated paraphrases being OR'd, only active memories by default, and fallback to keyword-only. It does not explicitly list exclusion cases but offers clear context for appropriate use.

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

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

No annotations provided; description does not disclose behavioral traits such as whether the mutation is destructive, permissions required, or error handling. The tool modifies a memory, but side effects are not mentioned.

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 sentence, direct and to the point, no redundant information. Efficiently conveys the core action.

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 mutation tool with no output schema or annotations, the description covers the basic purpose and allowed values. However, it lacks details on return value, error conditions, and behavioral context, leaving 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?

Schema description coverage is 0%, so description must compensate. Description lists the three confidence values, aiding understanding of the 'confidence' parameter, but does not explain the 'uid' parameter (e.g., it identifies a memory). Provides partial semantic 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?

Description clearly states the tool 'Set a memory's confidence' and lists the three allowed values (unverified, confirmed, contradicted). This distinguishes it from sibling tools like edit_memory or forget.

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 on when to use this tool versus alternatives. Does not mention prerequisites (e.g., memory must exist) or scenarios where it is appropriate.

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