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

With no annotations provided, the description carries the full burden of behavioral disclosure. It describes the action (pinging) and the returned information (status and latency), which covers basic behavior. However, it lacks details on potential errors, timeouts, or side effects (e.g., if it affects the Qdrant Cloud service), leaving some behavioral aspects unclear.

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, efficient sentence that directly states the tool's purpose and outcome without any redundant words. It is front-loaded with the core action and result, making it highly concise and well-structured.

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

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

Given the tool's simplicity (0 parameters, no output schema, no annotations), the description is adequate for basic understanding. However, it lacks details on output format (e.g., what 'status' includes) and error handling, which could be useful for an AI agent, making it minimally complete but with 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 tool has 0 parameters, and the schema description coverage is 100%, so no parameter documentation is needed. The description appropriately does not discuss parameters, earning a baseline score of 4 for this context, as it avoids unnecessary information.

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 action ('Ping Qdrant Cloud') and the outcome ('return connection status and latency'), using precise verbs and specifying the target resource. It effectively distinguishes this tool from its siblings, which focus on memory operations, preferences, sessions, or status, by highlighting its diagnostic/connection-testing 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 implies usage for checking Qdrant Cloud connectivity and latency, providing clear context for when to use it. However, it does not explicitly state when not to use it or name alternatives (e.g., other health-check tools), which prevents a score of 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It adds valuable context beyond basic function: it specifies that content is 'automatically scrubbed for secrets before embedding and storage,' which informs about data handling and preprocessing. However, it doesn't cover other behavioral aspects like permissions, rate limits, or error handling.

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, efficient sentence that front-loads the core action ('Store a new memory') and adds a critical behavioral detail ('Content is automatically scrubbed for secrets before embedding and storage') without any wasted words. Every part earns its place by enhancing clarity.

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 annotations, no output schema, and a mutation tool (adding memory), the description is adequate but has gaps. It covers the basic purpose and a key behavioral trait (scrubbing), but lacks details on return values, error conditions, or integration with sibling tools, making it minimally viable for a tool with 3 parameters and full schema coverage.

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

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

Schema description coverage is 100%, so the schema already documents all parameters (content, memoryType, project) with descriptions and an enum for memoryType. The description adds no additional parameter semantics beyond what the schema provides, such as details on scrubbing implementation or project association nuances, meeting the baseline for high 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 action ('Store a new memory') and resource ('memory'), specifying that content is scrubbed for secrets before embedding and storage. It distinguishes from siblings like 'aiana_memory_delete' or 'aiana_memory_search' by focusing on creation, but doesn't explicitly differentiate from 'aiana_preference_add' which might be a similar add operation for preferences.

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 alternatives is provided. It implies usage for storing memories but doesn't mention when to choose it over siblings like 'aiana_memory_import' or 'aiana_preference_add', nor any prerequisites or exclusions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states 'Permanently delete,' implying a destructive, irreversible mutation, which is useful. However, it lacks details on permissions, side effects, error handling, or response format, leaving significant gaps for a destructive 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, efficient sentence with zero waste. It front-loads the key action ('Permanently delete') and resource, making it immediately clear and appropriately sized for its 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 complexity (destructive mutation) and lack of annotations or output schema, the description is incomplete. It doesn't cover behavioral aspects like confirmation prompts, success/error responses, or dependencies, which are critical for safe agent invocation in this 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 input schema has 100% description coverage, with the 'id' parameter fully documented. The description adds no additional parameter semantics beyond what the schema provides, such as format examples or constraints. This meets the baseline of 3 when schema coverage is high.

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 ('Permanently delete') and resource ('a memory by its ID'), making the purpose unambiguous. However, it doesn't differentiate from sibling tools like aiana_memory_export or aiana_memory_search, which would require explicit comparison to earn a 5.

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 no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing memory ID), exclusions, or comparisons to siblings like aiana_memory_recall or aiana_memory_feedback, leaving the agent without contextual usage cues.

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

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

With no annotations provided, the description carries the full burden. It discloses the output format (JSONL-compatible array) and optional filtering behavior, which is useful. However, it lacks details on permissions, rate limits, whether this is a read-only operation, or potential side effects (e.g., if export triggers data processing). No contradiction with annotations exists since none are provided.

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, efficient sentence that front-loads the core purpose ('Export all stored memories...') and adds a secondary detail ('Optionally filter by project.') without redundancy. Every word earns its place, making it highly concise and well-structured.

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

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

Given the tool's moderate complexity (export operation with one optional parameter) and no annotations or output schema, the description is minimally adequate. It covers the basic action and filtering option but lacks details on output structure (beyond 'JSONL-compatible'), error handling, or integration with sibling tools. For a tool with no structured output documentation, more context would be helpful.

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

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

The schema description coverage is 100%, with the single parameter 'project' fully documented in the schema. The description adds marginal value by mentioning 'Optionally filter by project,' reinforcing the optional nature implied by the schema (0 required parameters). It doesn't provide additional syntax or format details beyond what the schema already covers.

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: 'Export all stored memories as an array of memory records (JSONL-compatible).' It specifies the verb (export), resource (memories), and output format. However, it doesn't explicitly differentiate from sibling tools like 'aiana_memory_import' or 'aiana_memory_search' beyond mentioning optional project filtering.

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 through the phrase 'Optionally filter by project,' suggesting this tool is for bulk export with optional filtering. However, it doesn't provide explicit guidance on when to use this versus alternatives like 'aiana_memory_search' (which might offer more granular filtering) or 'aiana_memory_recall' (which might retrieve specific memories). No exclusions 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?

With no annotations provided, the description carries full burden for behavioral disclosure. It states the tool's purpose and rating scale but lacks critical behavioral details: whether this is a write operation (implied by 'Record'), what permissions are required, whether feedback is reversible, how it affects future relevance, or any rate limits. The description provides minimal behavioral context beyond the basic 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 extremely concise (two short sentences) with zero wasted words. It's front-loaded with the core purpose and efficiently explains the rating scale. Every sentence earns its place by providing essential information without redundancy or unnecessary 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 mutation tool (implied by 'Record') with no annotations and no output schema, the description is incomplete. It lacks information about behavioral implications, error conditions, return values, or how the feedback integrates with the memory system. The description provides basic operation but misses critical context needed for proper tool invocation and understanding of consequences.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds minimal value beyond the schema by mentioning the rating scale (1=helpful, 0=neutral, -1=not helpful), which is already in the schema's enum description. No additional parameter context or usage guidance is provided beyond what's in the structured 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 ('Record feedback') and resource ('on a recalled memory') with the goal 'to improve future relevance'. It distinguishes from siblings like aiana_memory_add or aiana_memory_delete by focusing on feedback rather than creation or deletion. However, it doesn't explicitly differentiate from all siblings (e.g., aiana_memory_search).

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 ('on a recalled memory') and provides rating scale guidance, but doesn't explicitly state when to use this tool versus alternatives like aiana_memory_search or aiana_memory_recall. No exclusions or prerequisites are mentioned, leaving some ambiguity about appropriate usage scenarios.

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

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

With no annotations provided, the description carries the full burden. It discloses that duplicate IDs are overwritten, which is a key behavioral trait for mutation operations. However, it doesn't cover other aspects like permissions needed, rate limits, error handling, or what the tool returns, leaving gaps for a tool that modifies data.

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

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

The description is two sentences, front-loaded with the core action and resource, followed by a critical behavioral note about duplicates. Every word serves a purpose, with no redundancy or unnecessary elaboration, making it highly efficient and easy to parse.

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

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

Given no annotations and no output schema, the description is incomplete for a mutation tool. It covers the import action and duplicate handling but misses details on permissions, response format, error cases, or integration with sibling tools. This is adequate for basic understanding but lacks depth for safe and 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?

Schema description coverage is 100%, with the parameter 'memories' well-documented in the schema as an array of memory records from export. The description adds minimal value beyond the schema, only reiterating the source ('from aiana_memory_export'), so it meets the baseline for high coverage without compensating with additional insights.

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 ('import') and resource ('memories'), specifying they come from a previously exported array. It distinguishes from siblings like aiana_memory_add by focusing on bulk import from export data, but doesn't explicitly contrast with all siblings like aiana_memory_search or aiana_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 implies usage when importing from exported data, mentioning 'from aiana_memory_export', which suggests a workflow. However, it lacks explicit guidance on when to use this vs. alternatives like aiana_memory_add for single memories or aiana_memory_search for retrieval, and no exclusions or prerequisites are 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?

With no annotations provided, the description carries full burden. It discloses the tool's behavior: using project name as a semantic seed and returning top-N most relevant memories. However, it lacks details on permissions, rate limits, or what constitutes 'relevant' (e.g., recency, frequency).

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

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

The description is a single, well-structured sentence that efficiently conveys purpose, method, and output. Every word earns its place with no redundancy or fluff.

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

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

Given no annotations and no output schema, the description is adequate for a read-only recall tool but incomplete. It doesn't explain return format, error handling, or how 'relevance' is determined, which could be important for an AI 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?

Schema description coverage is 100%, so the schema already documents both parameters. The description adds marginal value by mentioning 'project name as a semantic seed' and 'top-N most relevant memories', which aligns with but doesn't significantly expand beyond the schema's parameter descriptions.

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

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

The description clearly states the verb ('recall') and resource ('memories') with specific scope ('for a project'). It distinguishes from siblings like aiana_memory_add (add), aiana_memory_delete (delete), and aiana_memory_search (search) by focusing on semantic recall of top-N relevant memories.

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 ('for a project') and mentions scoping to that project, but does not explicitly state when to use this tool versus alternatives like aiana_memory_search. No exclusions or prerequisites are provided, leaving some ambiguity.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions that it 'Returns memories ranked by relevance' but does not cover aspects like rate limits, authentication needs, error handling, or what constitutes a 'memory' in this context. This is insufficient for a search tool with potential operational constraints.

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 highly concise and front-loaded, consisting of two clear sentences that directly state the tool's function and output. There is no wasted language, and it efficiently communicates the core purpose without unnecessary 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?

Given the complexity of a semantic search tool with no annotations and no output schema, the description is incomplete. It does not explain the format of returned memories, how relevance is calculated, or any limitations (e.g., search scope or performance). This leaves significant gaps for an AI agent to understand the tool's behavior fully.

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

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

Schema description coverage is 100%, so the input schema fully documents all parameters. The description does not add any additional meaning beyond what the schema provides, such as explaining the semantic nature of the search or how the 'minScore' threshold affects results. Baseline 3 is appropriate as the schema handles parameter documentation.

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 'Semantic search over stored memories' with the action 'Returns memories ranked by relevance to the query.' It specifies the verb (search) and resource (memories) but does not explicitly differentiate from siblings like aiana_memory_recall, which might have overlapping functionality.

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 no guidance on when to use this tool versus alternatives such as aiana_memory_recall or other sibling tools. It lacks context on specific use cases, exclusions, or prerequisites, leaving the agent to infer usage based on the name alone.

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 states that preferences are stored as memories and are searchable/recallable, but lacks details on behavioral traits such as persistence, permissions, rate limits, or error handling. For a write operation (implied by 'Store') with no annotation coverage, this is insufficient.

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 zero waste, front-loaded with the core purpose and followed by a clarifying note on searchability. Every sentence adds value 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?

Given the tool's moderate complexity (write operation with 2 parameters), no annotations, and no output schema, the description is minimally adequate. It covers the basic purpose and memory type but lacks details on behavior, output, or integration with sibling tools, leaving gaps for an AI agent.

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

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

Schema description coverage is 100%, so the schema already documents both parameters (preference and project) with descriptions. The description adds no additional parameter semantics beyond what the schema provides, such as examples or constraints, meeting the baseline for high 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 action ('Store a user preference as a memory') and resource ('preference'), specifying that it's stored with type=preference. It distinguishes from generic memory tools by focusing on preferences, though it doesn't explicitly differentiate from sibling tools like aiana_memory_add.

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

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

The description mentions that preferences are 'searchable and recallable like any other memory,' which implies usage context but doesn't provide explicit guidance on when to use this tool versus alternatives like aiana_memory_add for general memories or other preference-related tools. No when-not-to-use or prerequisite information is included.

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 for behavioral disclosure. It mentions the grouping logic ('grouped by project') and sorting behavior ('sorted by most-recent activity'), but doesn't address important aspects like whether this is a read-only operation, potential rate limits, authentication requirements, or what happens when no sessions match the filter. For a tool with zero annotation coverage, this leaves significant behavioral gaps.

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 perfectly concise with two clear sentences that each earn their place. The first sentence states the core functionality and grouping logic, while the second explains session derivation and sorting behavior. No wasted words, and information is front-loaded effectively.

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

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

For a read-oriented tool with 2 parameters and 100% schema coverage but no output schema, the description provides adequate but incomplete context. It explains what sessions are and how they're sorted, but doesn't describe the return format, pagination behavior, or error conditions. Without annotations or output schema, more behavioral context would be helpful for agent decision-making.

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

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

Schema description coverage is 100%, so the schema already documents both parameters completely. The description doesn't add any parameter-specific information beyond what's in the schema. It mentions grouping by project which aligns with the 'project' parameter, but provides no additional syntax, format, or usage details. Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description clearly states the specific action ('List sessions grouped by project'), defines what sessions are ('derived from memories that share a sessionId'), and specifies the return order ('sorted by most-recent activity'). This distinguishes it from sibling tools like aiana_memory_search or aiana_memory_recall by focusing on session-level aggregation rather than individual memory operations.

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 no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like aiana_memory_search (which might retrieve individual memories) or explain scenarios where listing sessions by project is preferable to other memory-related operations. Usage context is implied but not explicitly 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?

No annotations are provided, so the description carries the full burden. It discloses the return data (stats like memory count and model), which is useful behavioral context. However, it lacks details on permissions, rate limits, error handling, or whether it's a read-only operation (implied by 'Return' but not explicit). For a tool with zero annotation coverage, this leaves significant gaps in behavioral understanding.

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, efficient sentence that front-loads the purpose ('Return collection stats') and lists key metrics. Every word earns its place, with no redundancy or fluff. It's appropriately sized for a simple, parameterless tool.

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 (simple, no parameters) and lack of annotations/output schema, the description is minimally complete. It explains what stats are returned, which is sufficient for basic use. However, it doesn't cover behavioral aspects like error cases or performance, leaving room for improvement despite the low complexity.

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

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

The tool has 0 parameters, and schema description coverage is 100%, so no parameter documentation is needed. The description doesn't add param info, which is appropriate. Baseline for 0 params is 4, as it correctly avoids unnecessary details and aligns with 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's purpose with a specific verb ('Return') and resource ('collection stats'), listing the specific metrics returned. It distinguishes from siblings like aiana_health (likely system health) and aiana_memory_search (searching memories), though not explicitly. However, it doesn't fully differentiate from aiana_session_list, which might also return stats-like data.

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

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

No guidance is provided on when to use this tool versus alternatives. The description doesn't mention prerequisites, timing, or comparisons to siblings like aiana_health (which might overlap for health stats) or aiana_memory_search (which might provide filtered data). Usage is implied only by the purpose, with no explicit when/when-not instructions.

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