AI Cortex Storage

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 does an excellent job describing critical behavioral traits: the account requirement ('active accounts'), the one-time nature of key display, and the security implication ('store it immediately'). It doesn't mention rate limits, authentication needs, or error conditions, but covers the most essential behavioral aspects well.

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 sentences that each earn their place. The first sentence states the core purpose, the second provides critical behavioral guidance. There's zero waste or redundancy, and the information is front-loaded appropriately.

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 creation tool with no annotations and no output schema, the description does well by covering the essential behavioral constraints. However, it doesn't describe what happens on success (what the API key looks like, format, length) or potential failure modes, which would be helpful given the absence of output schema and annotations.

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 100% schema description coverage and only one parameter, the schema already fully documents the 'label' parameter. The description doesn't add any parameter-specific information beyond what's in the schema, so it meets the baseline of 3 for high schema coverage situations.

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 ('Create a new live API key') and resource ('API key'), distinguishing it from sibling tools like 'list_api_keys' or 'revoke_api_key'. It provides a complete verb+resource+scope combination that leaves no ambiguity about what this tool does.

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

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

The description provides clear context about when to use this tool ('Only available for active accounts') and important behavioral constraints ('The key is shown once — store it immediately'). However, it doesn't explicitly mention when NOT to use it or name specific alternatives among the sibling tools, which prevents a perfect score.

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

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

The annotations already declare destructiveHint=true, indicating this is a destructive operation. The description adds minimal context by confirming it's a deletion action, but doesn't provide additional behavioral details such as whether deletion is permanent, if there are confirmation prompts, rate limits, or authentication requirements. No contradiction with annotations exists.

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—a single, clear sentence with zero wasted words. It's front-loaded with the core action ('Delete'), making it easy to scan and understand immediately. Every word earns its place by directly conveying the tool's purpose.

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

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

Given this is a destructive tool with no output schema, the description is incomplete. It doesn't cover what happens post-deletion (e.g., success/failure responses, error conditions), or how it relates to sibling tools in the memory/storage context (e.g., 'put_memory', 'get_memory'). The annotations provide safety hints, but more contextual guidance is needed 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?

Schema description coverage is 100%, with both parameters ('namespace' and 'key') fully documented in the schema. The description adds no meaning beyond what the schema provides—it doesn't explain how these parameters identify the 'stored value' or their relationship. Baseline score of 3 is appropriate since the schema carries the full parameter documentation burden.

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

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

The description clearly states the action ('Delete') and the resource ('a stored value'), which provides a specific verb+resource combination. However, it doesn't distinguish this tool from its sibling 'revoke_api_key' (which also performs deletion) or explain what type of 'stored value' it refers to versus other storage-related tools like 'put_memory' or '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 provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing value to delete), exclusions, or relationships to sibling tools like 'get_memory' (for checking existence) or 'put_memory' (for creating values). The agent must infer usage from the tool 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?

The annotations already declare readOnlyHint=true, indicating this is a safe read operation. The description adds some behavioral context by specifying what data is returned (status, credit balance, available credits), but doesn't mention other important behavioral aspects like authentication requirements, rate limits, error conditions, or whether this returns real-time or cached 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 extremely concise and front-loaded with all necessary information in a single, efficient sentence. There's zero wasted language, and every word contributes to understanding the tool's purpose.

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

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

For a read-only tool with no parameters and annotations covering safety, the description provides adequate basic information about what data is returned. However, without an output schema, the description doesn't specify the format or structure of the returned data (e.g., whether it's a simple object with fields, nested structures, etc.), which would be helpful for an AI agent to understand how to process the response.

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 parameters and 100% schema description coverage, the baseline would be 4. The description appropriately doesn't discuss parameters since there are none, and the schema fully documents the empty parameter set. No additional parameter information is needed or provided.

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 what the tool does ('Get account status, credit balance, and available credits'), providing a specific verb ('Get') and resource ('account') along with the specific data fields returned. However, it doesn't explicitly differentiate from sibling tools like 'list_payments' or 'settle_balance' which might also relate to account information.

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. There's no mention of prerequisites, when this should be called versus other account-related tools like 'list_payments' or 'settle_balance', or any contextual constraints for 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?

Annotations declare readOnlyHint=true, indicating a safe read operation, which the description aligns with by using 'Retrieve'. The description adds minimal behavioral context beyond annotations, such as specifying what gets retrieved (a stored value) but doesn't mention error handling (e.g., if key doesn't exist) or performance aspects. No contradiction with annotations.

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

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

The description is a single, efficient sentence that directly states the tool's purpose without any redundant information. It is front-loaded and wastes no words, 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 low complexity (simple retrieval), high schema coverage (100%), and annotations covering safety (readOnlyHint), the description is adequate but minimal. It lacks details on output (no output schema provided) and error cases, which could be helpful for an agent. However, it suffices for basic understanding 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?

Schema description coverage is 100%, with both parameters ('namespace' and 'key') well-documented in the schema regarding type, constraints, and format. The description adds no additional semantic details beyond what the schema provides, such as examples or usage context, so it meets 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 ('Retrieve') and resource ('stored value'), with specific identifiers ('namespace and key'). It distinguishes from siblings like 'put_memory' (write) and 'delete_memory' (delete), but doesn't explicitly differentiate from 'list_keys' or 'top_memories' which might also involve retrieval 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?

No guidance is provided on when to use this tool versus alternatives like 'list_keys' (which might list keys without retrieving values) or 'top_memories' (which might retrieve based on ranking). The description implies usage for retrieving specific stored data but lacks explicit context 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?

The description adds minimal behavioral context beyond the annotations, which already indicate readOnlyHint=true, confirming it's a safe read operation. It implies a listing action but doesn't disclose details like pagination, sorting, or error handling. No contradiction with annotations exists, so it meets the baseline for having annotations.

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

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

The description is a single, direct sentence with no wasted words, clearly front-loading the core functionality. It efficiently communicates the tool's purpose without unnecessary elaboration, 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, read-only annotation, no output schema), the description is adequate as a basic listing tool. However, it lacks details on output format or behavioral nuances, which could be helpful for an agent. It meets the minimum viable standard but doesn't fully leverage the context to provide richer guidance.

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 parameters and 100% schema description coverage, the input schema fully documents the lack of inputs. The description aligns by not mentioning any parameters, which is appropriate. A baseline of 4 is applied since no parameters are present, and the description doesn't add or detract from the schema.

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

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

The description clearly states the action ('List') and resource ('all API keys on this account'), making the purpose immediately understandable. However, it does not explicitly differentiate from sibling tools like 'list_keys' or 'get_account', which might have overlapping or related functionality, preventing a perfect score.

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 'list_keys' or 'get_account', nor does it mention any prerequisites or context for usage. It simply states what the tool does without indicating appropriate scenarios 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?

Annotations declare readOnlyHint=true, which the description aligns with by describing a list operation. The description adds valuable behavioral context beyond annotations: it specifies the return limit (up to 1000 keys), sorting (by recency), automatic exclusion of expired keys, and metadata fields included. This enhances the agent's understanding of the tool's behavior.

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

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

The description is front-loaded with the core purpose and key details (metadata, limit, sorting, exclusion) in two efficient sentences. Every sentence adds value without redundancy, making it highly concise and well-structured for quick comprehension.

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 low complexity (one required parameter) and rich annotations (readOnlyHint), the description is mostly complete. It covers behavior, output details, and constraints. However, without an output schema, it could benefit from clarifying the return format (e.g., list structure), but the metadata fields are listed, which partially compensates.

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 'namespace' fully documented in the schema. The description does not add any parameter-specific details beyond what the schema provides, such as examples or constraints not in the schema. This meets 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 verb ('List') and resource ('keys in a namespace') with specific scope ('with metadata...'). It distinguishes from siblings like 'list_namespaces' (lists namespaces) and 'list_api_keys' (lists API keys), making the purpose unambiguous.

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

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

The description implies usage for retrieving keys with metadata in a namespace, but does not explicitly state when to use this tool versus alternatives like 'list_namespaces' or 'search_by_tag'. No exclusions or prerequisites are mentioned, leaving some ambiguity for the agent.

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

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

The annotations already indicate readOnlyHint=true, so the agent knows this is a safe read operation. The description adds no behavioral context beyond this, such as pagination, rate limits, or authentication needs. It doesn't contradict annotations, but adds minimal value beyond them.

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

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

The description is a single, efficient sentence that states the tool's purpose without any wasted words. It's front-loaded and appropriately sized for a simple list operation, making it easy for an agent to parse quickly.

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

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

For a simple list tool with read-only annotations and no parameters, the description is adequate but minimal. It lacks details on output format, error handling, or account context, which could be helpful given no output schema. It meets basic needs but leaves gaps 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?

With 0 parameters and 100% schema description coverage, the schema fully documents the input requirements. The description doesn't need to add parameter details, and it correctly implies no inputs are required, aligning with the schema. A baseline of 4 is appropriate for zero-parameter tools.

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 resource ('all namespaces for this account'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'list_api_keys' or 'list_keys' beyond the resource type, which prevents a perfect score.

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, context for usage, or comparisons to sibling tools like 'get_account' or 'search_by_tag', leaving the agent with minimal usage direction.

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

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

The annotations already declare readOnlyHint=true, indicating a safe read operation. The description adds minimal behavioral context by implying historical data retrieval, but doesn't disclose details like rate limits, authentication needs, or what 'payment history' entails beyond the schema. It doesn't contradict annotations, so no penalty.

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 with zero wasted words. It's appropriately sized and front-loaded, 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 low complexity (read-only, two optional parameters) and good schema coverage, the description is minimally adequate. However, without an output schema, it doesn't explain return values or format, and it lacks context on scope or limitations, leaving gaps for the 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?

With 100% schema description coverage, the input schema fully documents the 'limit' and 'offset' parameters. The description adds no additional parameter semantics beyond what's in the schema, so it meets the baseline for high coverage without compensating value.

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

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

The description clearly states the action ('List') and resource ('payment history for this account'), making the purpose understandable. However, it doesn't differentiate from potential sibling tools like 'settle_balance' or 'search_by_tag' that might also involve payments, so it's not fully specific to sibling context.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, exclusions, or compare to other payment-related tools like 'settle_balance', 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?

The description adds valuable behavioral context beyond the idempotentHint annotation. It discloses the 1 MB size limit for value_json, default storage duration (1 month), and the unique overwrite behavior where existing expiry is scaled by KB size ratio. This provides operational insights not covered by the annotation alone.

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 sentences) and front-loaded with the core purpose. Every sentence provides essential information: the storage operation with optional features, size constraint, and overwrite behavior. Zero wasted words.

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

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

For a tool with rich schema documentation (100% coverage) and an idempotentHint annotation, the description provides good contextual completeness. It covers key behavioral aspects like size limits and overwrite logic. The main gap is lack of output information (no output schema), but the description compensates reasonably given the structured data available.

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 100% schema description coverage, the input schema already documents all parameters thoroughly. The description mentions 'optional tags, priority, and storage duration' and the overwrite behavior, but doesn't add significant semantic meaning beyond what's in the schema. This meets 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 verb ('Store') and resource ('a value') with specific optional features (tags, priority, storage duration). It distinguishes from siblings like 'delete_memory', 'get_memory', 'list_keys', and 'search_by_tag' by focusing on storage/overwrite functionality rather than retrieval, deletion, or listing.

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 clear context for usage: storing values with metadata and handling overwrites. However, it doesn't explicitly state when to use this tool versus alternatives like 'create_api_key' or 'submit_feature_request', nor does it mention prerequisites or exclusions beyond the technical constraints.

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

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

The description adds valuable behavioral context beyond the 'destructiveHint: true' annotation by specifying that 'The key stops working immediately,' which clarifies the timing and irreversible effect. However, it does not mention rate limits, authentication needs, or 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?

The description is two sentences with zero waste, front-loading the action ('Revoke an API key by ID') and efficiently adding critical behavioral detail ('stops working immediately'). Every sentence earns its place.

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

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

Given the tool's complexity (destructive operation with one parameter), the annotations cover safety, and the schema fully documents inputs. The description adds key behavioral context, but without an output schema, it could benefit from mentioning return values or confirmation details.

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, fully documenting the 'key_id' parameter. The description does not add meaning beyond the schema, such as format details or examples, so it meets the baseline for high schema coverage without extra value.

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

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

The description clearly states the specific action ('revoke') and resource ('API key by ID'), and distinguishes it from sibling tools like 'create_api_key' and 'list_api_keys' by focusing on deactivation rather than creation or listing.

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 an API key needs to be disabled ('stops working immediately'), but does not explicitly state when to use this tool versus alternatives like 'delete_memory' or provide exclusions. It offers clear context but lacks explicit guidance on alternatives.

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

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

Annotations already declare readOnlyHint=true, indicating a safe read operation. The description adds useful behavioral context by specifying the result limit ('up to 1000 results') and the return format ('(namespace, key) pairs'), which goes beyond the annotations. However, it doesn't detail pagination, error handling, or performance characteristics.

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 with two sentences that directly convey purpose and constraints. Every word earns its place, with no redundant or vague phrasing, making it easy to parse and understand 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, read-only, no output schema), the description is reasonably complete. It covers the core functionality and result limit. However, it lacks details on error cases or what happens if no matches are found, leaving minor gaps for a search 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 description coverage is 100%, so the schema already fully documents the single 'tag' parameter. The description repeats the result limit information but adds no additional semantic meaning about the parameter beyond what the schema provides, 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 specific action ('Find'), the target resources ('(namespace, key) pairs'), and the search criterion ('with a given tag'). It distinguishes from siblings like list_keys or list_namespaces by focusing on tag-based filtering rather than listing all items.

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 tag-based searches but provides no explicit guidance on when to use this tool versus alternatives like list_keys or list_namespaces. It mentions the result limit ('up to 1000 results'), which offers some context but doesn't clarify exclusions or specific 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 of behavioral disclosure. It effectively describes key behavioral traits: the requirement for user approval (a safety/authorization constraint), conditional behavior for trial accounts (returns URL instead of charging), and a minimum charge amount ($5). However, it doesn't cover potential error conditions or rate limits.

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 and front-loaded: three sentences that each earn their place by providing distinct, essential information (core action, user approval requirement, trial account behavior, and minimum charge). There's zero wasted text or redundancy.

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

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

Given the tool's complexity (a financial transaction with conditional behavior), no annotations, and no output schema, the description does well by covering the core action, prerequisites, and special cases. However, it doesn't describe the return value format or potential error scenarios, leaving some gaps for the 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?

The tool has 0 parameters with 100% schema description coverage, so the baseline is 4. The description doesn't need to explain parameters, but it does provide context about the transaction (minimum charge: $5) which adds semantic value 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 tool's purpose with specific verbs ('charges', 'settle') and resource ('outstanding balance'), distinguishing it from sibling tools like list_payments or get_account. It precisely defines what the tool does: initiating a payment transaction to clear a balance.

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 usage guidelines: it specifies when to use (to settle an outstanding balance), when not to use (requires explicit user approval, implying it shouldn't be run automatically), and an alternative scenario (for trial accounts, returns activation URL instead). This clearly guides the agent on appropriate invocation contexts.

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 and effectively discloses key behavioral traits: it's free (no credits charged), idempotent (first submission recorded, duplicates ignored), and has a truncation limit (2000 chars for detail). It doesn't mention error handling or response format, but covers most critical aspects.

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?

Perfectly concise with three focused sentences that each provide essential information: purpose, behavioral constraints, and usage context. No wasted words and front-loaded with the core functionality.

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

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

For a mutation tool with no annotations and no output schema, the description provides excellent context about when to call it and behavioral constraints. It could mention what happens after submission (e.g., confirmation) but covers the most important aspects given 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?

Schema description coverage is 100%, so the schema already fully documents both parameters. The description doesn't add any parameter-specific information beyond what's in the schema, meeting the baseline expectation 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 specific action ('submit feedback') and context ('when a trial ends without activation'), distinguishing it from sibling tools like 'submit_feature_request' which is for different feedback types. It precisely defines the verb and resource scope.

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

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

Explicitly states when to use this tool ('when the user declines to activate or the trial is exhausted') and provides clear exclusions ('Only the first submission per account is recorded; duplicates are silently ignored'), giving perfect guidance for 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 of behavioral disclosure. It adds valuable context beyond basic functionality: it specifies pricing details ('Charged at storage rate: ceil_kb(description_length) × 100 credits per KB') and account accessibility ('Available to trial and active accounts alike'). This helps the agent understand cost implications and eligibility, though it doesn't cover other aspects like response format 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 concise and front-loaded, stating the core purpose in the first clause. The additional sentences about pricing and account availability are relevant and add necessary context without redundancy. However, the pricing explanation could be slightly simplified for clarity, and there's minor room for improvement in flow.

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 (1 parameter, no output schema, no annotations), the description is moderately complete. It covers purpose, pricing, and accessibility, but lacks details on expected outcomes (e.g., confirmation message, error cases) or integration with sibling tools. For a submission tool with potential cost implications, more behavioral context would enhance 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 input schema has 100% description coverage, with the single parameter 'description' documented as 'Description of the requested feature (truncated at 10,000 chars).' The tool description doesn't add any parameter-specific information beyond what's in the schema, such as formatting examples or usage tips. With high schema coverage, the baseline score of 3 is appropriate, as the description doesn't compensate with extra semantic 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: 'Submit a feature request or product feedback.' It uses specific verbs ('submit') and identifies the resource ('feature request or product feedback'), making the action unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'submit_exit_feedback', which is a similar feedback mechanism but for different content.

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 some usage context by stating it's 'Available to trial and active accounts alike,' implying no account restrictions. However, it lacks explicit guidance on when to use this tool versus alternatives like 'submit_exit_feedback' (which appears to be for exit-related feedback) or other feedback mechanisms. 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?

Annotations declare readOnlyHint=true, and the description adds valuable behavioral context beyond that: it specifies the tool returns only non-expired keys, mentions the maximum n value (1000), and implies a filtering mechanism based on priority. No contradictions with annotations exist.

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 core functionality in the first sentence, followed by a usage tip and constraint. Every sentence adds value with zero waste, making it highly efficient.

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

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

Given the tool's moderate complexity (filtering by priority and expiration), annotations cover safety (read-only), and schema fully describes inputs, the description is mostly complete. However, without an output schema, it could benefit from clarifying the return format (e.g., list of keys with priorities).

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 fully documents parameters. The description adds minimal semantics by mentioning 'top N' and 'max 1000', which aligns with the schema but does not provide additional meaning beyond it.

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 ('Return'), resource ('top N highest-priority non-expired keys in a namespace'), and ordering ('ordered by priority descending'). It distinguishes from siblings like 'list_keys' by specifying priority-based filtering and ordering.

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 clear context for when to use this tool ('Useful for loading the most important context when space is limited'), but does not explicitly mention when not to use it or name alternative tools like 'list_keys' or 'get_memory' for different scenarios.

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