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

With no annotations, the description must disclose behavior. It only states the action 'detect' which implies read-only operation, but does not explain the output format, side effects, or requirements. It does not contradict annotations since there are none, but it 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 a single, direct sentence with no wasted words. It is appropriately front-loaded, though minimalism comes at the cost of missing details.

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

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

The tool has a simple schema but no output schema or annotations. The description fails to explain what constitutes a conflict, what the result shape is, or how it relates to other analysis tools. This is inadequate for an agent to understand its full utility.

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

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

The schema already provides descriptions for both optional parameters, covering 100% of them. The tool description adds no additional parameter context, so the baseline score of 3 applies.

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

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

The description clearly states the tool detects conflicts between memory entries, using a specific verb and resource. It distinguishes from sibling search tools by focusing on conflict detection, though it does not define what constitutes a conflict or the scope of detection.

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 memory_search or analysis_memory_map. The description does not specify use cases, prerequisites, or conditions under which conflict detection is appropriate.

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 responsibility for disclosing behavior. It only states the action without indicating whether this is read-only, whether it has side effects, or what the output structure is. 'Generate' implies creation, but no details on irreversibility or dependencies are given.

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

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

The description is a single concise sentence with no redundant words, front-loading the core idea. While brief, it is not bloated, though it could be slightly expanded 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?

With no output schema or annotations, the description should explain what 'memory map visualization data' actually includes, but it does not. The tool is simple, yet the missing output details and lack of context for how this data can be used make it incomplete.

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 single project_id parameter clearly documented as an optional filter. The description adds no additional meaning beyond the schema, which is acceptable given the high coverage baseline.

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 'generate' and a distinct resource 'memory map visualization data', which clearly differentiates it from sibling tools like memory_search or analysis_conflicts. The naming is consistent with its purpose, though it doesn't elaborate on what the visualization data contains.

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 does not mention any prerequisites, use cases, or exclusions, leaving the agent to infer context from 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 available, so the description bears full responsibility for behavioral disclosure. It doesn't state whether this tool writes to storage (spec_id suggests it), what side effects occur, permission requirements, or limitations. The ambiguous nature of 'analyze' plus spec_id implies a write operation, but this is never clarified.

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

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

The description is a single concise sentence with no waste. It is front-loaded with the core action. However, it is arguably too brief, omitting important behavioral details, though this is more a completeness issue than a structure issue.

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

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

The tool has no output schema, no annotations, and a terse description. It doesn't explain what the analysis returns, how results are stored, or any caveats about the frameworks. For a tool that likely scans code and persists findings, this is inadequate guidance for an agent to invoke it correctly.

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

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

Schema description coverage is 100%: all three parameters (spec_id, source_path, framework) have descriptions. The tool description adds no additional parameter semantics, such as how framework auto-detection works or the relationship between source_path and spec_id. Baseline 3 is appropriate since the schema carries the parameter 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 action ('Analyze codebase for API endpoints') and lists target frameworks (FeathersJS, Express, Fastify). It distinguishes from sibling tools like get_api_endpoints, which retrieve stored endpoints rather than analyzing source code. However, it doesn't explicitly mention that results are stored via spec_id, leaving slight ambiguity about the output.

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, nor does it mention exclusions or context. Despite the presence of sibling tools for API specs and routing patterns, no comparison or selection criteria is given. The user must infer usage solely from the tool name and schema.

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 disclosing behavior. It lists the data sources but does not state whether the operation is read-only, whether it mutates any memory, what the return value looks like, or what 'active context' means practically. This is a significant transparency gap.

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

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

The description is a single, front-loaded sentence with zero fluff. It is concise and easy to read, though the brevity leaves out usage and behavioral details that could be included without much bloat.

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?

There is no output schema and no annotations, so the description needs to explain what the assembled context returns and when to use the tool. It only lists the input sources, leaving the agent without enough information to confidently invoke the tool or interpret its results.

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% coverage with descriptive parameter definitions, so the baseline is 3. The description adds no additional parameter context, but the schema already explains query, mode, limit, and session_id adequately.

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 the verb 'assemble' and specifies the resources (prompt modules, markdown memory, SQLite memory), making the primary function clear. It distinguishes itself from sibling tools by implying a cross-source aggregation, though 'active context' remains somewhat vague.

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 a combined context from multiple memory sources is needed, but it does not explicitly state when to prefer this tool over alternatives like retrieve_session_context or memory_search. No exclusions or alternative recommendations are provided.

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 must disclose behavioral traits. It states 'Remove' (destructive) but does not mention irreversibility, scope (does it affect only sessions or related data?), permissions required, or side effects. The schema adds a default of 30 days, but the description itself lacks critical safety context.

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

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

The description is a single, concise sentence of six words: 'Remove sessions older than specified days.' It is front-loaded with the action and resource, with no filler or redundancy.

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

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

For a destructive cleanup tool with one parameter and no output schema, the description is too sparse. It does not explain what qualifies as 'older', whether the operation is permanent, or what happens to related contexts (e.g., session memory). This is a significant gap given the lack of 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?

Schema coverage is 100% for the single 'days' parameter, which includes a description and default value. The tool description adds no extra meaning beyond what the schema provides, so it meets the baseline but does not enhance parameter understanding.

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 ('Remove') and resource ('sessions') with a clear condition ('older than specified days'). It is unambiguous and distinguishes itself from sibling tools like store_session_context or retrieve_session_context, which handle session creation/retrieval, not cleanup.

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. There is no mention of prerequisites (e.g., whether this is for maintenance), nor any exclusions or alternative tool referrals. The description simply states what it does, 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 must fully disclose behavioral details. It only states 'Create a new task' without mentioning return values, side effects, error handling, or any operational nuances, offering virtually no 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 a single concise sentence with no filler words. It is front-loaded with the action, but its brevity borders on under-specification, though that issue is handled in other dimensions.

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 8 parameters, no output schema, and no annotations, the description is incomplete. It lacks information about what the tool returns on success or failure, how it integrates with related task tools, and any operational context needed for an agent to use it 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 coverage is 100%, so the baseline is 3. The description adds no parameter-specific meaning beyond what the schema already provides, but it does not need to, given the complete 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's function: creating a new task in the task tracking system. It uses a specific verb ('create') and resource ('task'), distinguishing it from sibling tools like update_task and delete_task.

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

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

The description gives no guidance on when to use this tool versus alternatives such as update_task or delete_task. It lacks any context for prerequisites or conditions, leaving the agent to infer 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?

No annotations are present, so the description must carry the full burden. It mentions reading from operational memory but does not disclose whether the operation is read-only, whether it has side effects, or what 'proactive' means behaviorally. No return format is described.

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

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

The description is a single concise sentence that front-loads the action and source. While efficient, it could earn its place by adding a brief note about output or usage context, but for a zero-parameter tool this is nearly optimal.

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 output schema and no annotations, the description is the only source of context. It fails to explain what the daily briefing contains, whether it returns a summary, or whether any state changes occur. This is insufficient even 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?

The tool has zero parameters, and the schema is trivially covered (100%). The baseline for 0 parameters is 4, and the description does not need to add 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 uses a specific verb ('Generate') and resource ('daily briefing') and clarifies the source ('operational memory'). It distinguishes from sibling tools like 'weekly_review' by specifying the daily timeframe and proactive nature.

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

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

No guidance is provided on when to use this tool versus alternatives such as 'weekly_review' or 'assemble_active_context'. The description implies a daily use case but offers no exclusions or explicit 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?

With no annotations, the description carries full responsibility for behavioral disclosure. It clearly indicates a destructive cascading operation ('Delete API specification and all related endpoints/schemas'), which is valuable, but it omits important details such as irreversibility, permission requirements, or whether deletion is hard or soft.

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

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

The description is a single concise sentence that front-loads the action and clearly states the resource and scope. Every word earns its place with 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?

Given the tool's simplicity (one well-defined parameter), the description covers the core operation and cascade effect. However, for a destructive tool with no annotations or output schema, additional details about what happens after deletion (e.g., confirmation, irreversible action, affected related data) would make it more complete.

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

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

Schema description coverage is 100%, as spec_id is described as 'API spec identifier,' so the baseline is 3. The description adds no extra meaning about the parameter format, purpose beyond the name, or relationship to the deleted endpoints/schemas.

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

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

The description states a specific verb ('Delete') and resource ('API specification') while also specifying the scope: 'and all related endpoints/schemas.' This clearly differentiates it from sibling tools like get_api_spec, list_api_specs, and store_api_spec.

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 offers no explicit guidance on when to use this tool versus alternatives. It does not mention any preconditions, exclusions, or alternative tools, leaving the agent to infer usage from the tool name and purpose.

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 must carry the full burden of behavioral disclosure. It only states 'Delete a task by ID' and gives no information about whether the deletion is permanent, reversible, or what happens if the task does not exist. This lack of context is a significant gap 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 one short, front-loaded sentence with no wasted words. It directly and clearly conveys the tool's purpose without unnecessary elaboration, making it effectively concise.

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 single-parameter deletion tool, the description provides the core action but omits behavioral details such as success/failure responses, idempotency, or error handling. Given the minimal complexity, this is adequate but leaves room for better context, especially since no output schema exists to clarify the return value.

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% for the single parameter 'id', which is described as 'Task ID to delete'. The tool description adds no additional semantic meaning beyond restating the parameter name and use. Since the schema already documents the parameter fully, the baseline of 3 is appropriate.

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

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

The description clearly states the action ('Delete') and the resource ('a task by ID'). This distinguishes it from sibling tools like create_task, update_task, and get_tasks, which use different verbs and resources. It is a specific, unambiguous statement.

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 given on when to use this tool versus alternatives, nor are any prerequisites, exclusions, or contextual cues provided. The description merely states the action without explaining when it is appropriate to invoke delete_task over other task-related tools.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states only that it 'adds an evolution note' but does not disclose whether it mutates the memory, how the optional new_value is applied, whether memory_id must exist, or what the response/outcome is. This is a significant transparency gap for a write 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 concise single sentence with no filler. It is front-loaded with the action ('Add an evolution note') and includes the purpose, making it 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?

For a mutation tool with no annotations and no output schema, the description is incomplete. It does not explain whether new_value updates the memory's current value, whether the evolution note is appended to a history log, or how this tool differs from update_memory. Missing these key details makes the context insufficient for an agent to select and invoke 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 100%, so the description does not need to repeat parameter details. However, the description adds no extra meaning beyond the schema; it aligns with evolution_note but does not clarify the role of new_value or the relationship between 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 action ('Add an evolution note') and the resource (memory), with a stated purpose ('to track changes over time'). It distinguishes itself from siblings like update_memory and store_memory by emphasizing the note-based evolution tracking, though it does not explicitly name alternatives.

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

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

The phrase 'to track changes over time' implies when the tool should be used, but the description provides no explicit guidance on when not to use it or how it compares to alternatives like update_memory or store_memory. The usage context is only implicit.

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

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

With no annotations, the description carries full responsibility for disclosing behavioral traits. It merely states the purpose without mentioning return format, confidence thresholds, ordering, or any side effects. This is a minimal and insufficient disclosure for a tool that likely performs a search operation with configurable parameters.

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

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

The description is a single, well-structured sentence that front-loads the core purpose. Every word earns its place, and there is no redundant elaboration. It is appropriately concise.

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

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

The tool has three parameters, no output schema, and no annotations, yet the description does not explain what results look like, how 'similar' is determined, or how confidence and limit affect outcomes. This leaves the agent with significant uncertainty about invocation and interpretation.

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 already provides descriptions for all three parameters (description, limit, min_confidence), achieving 100% coverage. The description text doesn't add extra meaning beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description clearly states the action ('Find') and the resource ('routing patterns') with a qualifier ('similar to a description'). It effectively distinguishes from sibling tools like search_patterns by focusing on routing patterns specifically. However, it doesn't elaborate on what 'similar' means, leaving some ambiguity about the matching mechanism.

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. Sibling tools such as search_patterns and get_routing_patterns exist, but the description offers no comparison or exclusions, leaving the agent to guess the appropriate 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?

With no annotations, the description carries the transparency burden. It clearly states the tool is read-only ('Get') and that it returns 'full endpoint details including request/response schemas', which communicates the kind of data returned. However, it omits error behavior or permission requirements, which would be useful but are not critical for a simple getter.

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, front-loaded sentence with no filler. Every word contributes to specifying the tool's function and return content.

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 simplicity of the tool (3 required params, no nested objects) and full schema coverage, the description is largely complete for a basic retrieval. It identifies what is returned, though a list of exact response fields would be helpful given the absence of an output schema, but this is not a major 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?

The schema covers all three parameters with descriptions, so the baseline is 3. The description adds no extra semantic meaning about the parameters (e.g., how they work together or what format the path should take), so it does not surpass the schema's 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 uses a specific verb ('Get') and resource ('endpoint details') and adds the scope 'including request/response schemas', which clearly distinguishes it from sibling tools like get_api_endpoints (likely for listing) and get_api_schema (likely for full-spec schemas).

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 about when to use this tool versus alternatives such as get_api_endpoints or get_api_schema. The description gives no context for choosing this tool over similar API-spec tools, leaving the agent to infer usage from 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?

With no annotations, the description carries the full burden for behavioral disclosure. It only states 'Query', which implies a read-only operation, but does not disclose pagination behavior, filter semantics, result format, authentication needs, or any side effects. The behavior is minimally transparent.

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

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

The description is a single concise sentence with no filler. It front-loads the action and resource clearly. 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 lack of annotations and output schema, the description is too sparse to be complete. It fails to mention return format, pagination beyond the limit parameter, filter combination rules, or how this tool differs from similar-looking siblings. For a tool with 5 optional parameters, more contextual detail is needed.

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

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

Schema coverage is 100%, with each parameter having a description. The tool description adds little beyond the word 'filters', which does not enrich understanding of parameter interactions. The schema already documents the parameters adequately, so a baseline score of 3 is appropriate.

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

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

The description clearly states a specific action ('Query') on a specific resource ('API endpoints') and mentions filtering. However, it does not distinguish from the closely named sibling tool 'search_api_endpoints', so it lacks sibling differentiation.

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 'search_api_endpoints' or 'get_api_endpoint_detail'. The description only implies use for querying, but does not explain 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?

No annotations are provided, so the description carries the burden. The verb 'Get' implies a read-only operation with no side effects, but it does not explicitly state this, nor does it mention any prerequisites or error conditions. For a simple retrieval, this is minimal but acceptable.

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 filler words. It is appropriately sized for the tool's complexity.

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

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

The tool is simple with two clear parameters and no output schema. The description 'Get schema definition from API spec' adequately conveys the tool's purpose and return value, though it could benefit from noting the format of the schema definition or providing a usage example. Given the low complexity, this is sufficient.

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?

Both parameters have descriptions in the schema (spec_id as 'API spec identifier', schema_name as 'Schema name'), covering 100% of parameters. The description does not add any additional parameter semantics beyond what the schema provides, so it meets the baseline.

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 the specific verb 'Get' and clearly identifies the resource as 'schema definition from API spec'. It distinguishes from sibling tools like get_api_spec and get_api_endpoints by focusing specifically on schema definitions within an API spec.

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?

There is no explicit guidance on when to use this tool versus alternatives, nor any exclusions. The usage is implied by the name and description: use it when you need a schema definition, while other tools cover API specs and endpoints.

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 is the only source of behavioral context. It correctly implies a safe read operation, but lacks details on output format, error behavior, or any authentication/authorization requirements. It adds minimal behavioral context beyond 'retrieve'.

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, clear sentence with no unnecessary words. It is well-structured and directly states the function.

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 one parameter and no output schema, the description covers the basic action but omits context such as what qualifies as 'full' specification or how to handle missing IDs. Given the availability of several similar API-related sibling tools, additional distinguishing context would improve completeness. A score of 3 reflects adequate but not thorough information.

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

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

The schema fully describes spec_id at 100% coverage. The description does not add any additional parameter semantics, such as format constraints or expected value patterns. Baseline 3 applies.

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

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

The description uses a specific verb 'Retrieve' with a clear resource 'full API specification' and the method 'by ID'. It distinguishes from sibling tools like list_api_specs (listing) and get_api_endpoints (endpoints only).

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 a clear context (retrieve a spec by ID) but does not explicitly explain when to use it over alternatives like get_api_endpoint_detail or get_api_schema. No exclusion criteria or alternative recommendations are given.

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 does not mention whether the operation is read-only, any side effects, time windows for 'recently', ordering, or pagination behavior. For a list tool, this is a notable gap, especially without annotation support.

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

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

The description is a single, concise sentence that effectively communicates the core purpose. It is front-loaded with the action and resource, with no filler or repetition.

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

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

The tool has 5 optional filter parameters and no output schema, yet the description does not clarify return structure, ordering, or time-based definition of 'recently read'. Given the lack of annotations and output schema, the description is minimally adequate but leaves gaps for an agent to infer behavior.

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

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

All 5 parameters are described in the schema (100% coverage), so the schema does the heavy lifting. The description only adds the context of 'recently read' and 'feedback and ranking', which does not directly explain parameter semantics. Baseline 3 is appropriate.

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

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

The description clearly states the tool's function: listing recently read durable memory artifacts. The verb 'List' is specific and the resource is well-defined. However, it does not explicitly distinguish itself from sibling tools like memory_search or get_memory, which may also return memory-related 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?

The description implies usage (for feedback and ranking of recently read artifacts) but provides no explicit guidance on when to use this tool versus alternatives. No exclusions or alternative tool references are mentioned, leaving the agent to infer 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 are provided, so the description carries full responsibility. It implies a read-only list operation and mentions 'recent', suggesting time-based ordering, but it does not disclose return format, pagination, or potential side effects. The slight mismatch between the tool name ('metrics') and description ('runs') adds 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 a single, clear sentence with no redundant information. It is front-loaded with the action verb and directly conveys 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?

The description gives a clear one-line purpose, and the schema covers all parameters, but there is no output schema to explain return values. The tool's domain-specific concept 'autodream runs' is not defined, and the metrics/runs mismatch leaves the agent uncertain about what data is returned. This is adequate but not complete.

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

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

Schema description coverage is 100%, with each parameter (limit, project, session_id) already well described in the schema. The description adds no additional parameter semantics, which is acceptable given the high coverage; the baseline of 3 is appropriate.

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

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

The description clearly states the tool lists recent autodream runs from the session-memory database, using a specific verb ('List') and resource ('autodream runs'). It distinguishes itself from sibling tools like memory_search or retrieve_session_context, none of which mention autodream.

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, nor any exclusions or prerequisites. It simply states what it does, leaving the agent to infer usage context 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?

With no annotations provided, the description carries full responsibility for behavioral disclosure. 'Retrieve' implies a non-destructive read, but it does not disclose requirements like session_id (though in schema), pagination behavior, error outcomes, or any side effects. The description is too thin to inform the agent about the tool's operational 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 short and front-loaded, which is structurally concise. However, it is under-specified for a tool with multiple parameters and no output schema, making the brevity less a strength and more a gap in information.

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

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

Given the absence of an output schema and the presence of several similar sibling tools, the description is incomplete. It does not explain return values, ordering, pagination, or how it differs from tools like retrieve_session_context or get_recent_activity. The minimal description leaves significant gaps for an agent trying to use the tool correctly.

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

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

The input schema has 100% description coverage for all three parameters (session_id, limit, since), so the schema itself provides adequate semantic meaning. The description adds no additional parameter context, but the baseline of 3 is appropriate since the schema does the heavy lifting.

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

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

The description 'Retrieve conversation history' uses a specific verb (retrieve) and resource (conversation history), clearly indicating a read operation for historical conversation data. However, it does not differentiate from similar sibling tools like retrieve_session_context, which also deals with session-related 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?

The description provides no guidance on when to use this tool versus alternatives such as retrieve_session_context or get_recent_activity. There is no mention of appropriate contexts, prerequisites, or exclusions, leaving the agent to guess the tool's intended role.

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 disclosing behavior. 'Get memories' implies a read operation, but it does not disclose filtering semantics (e.g., how branch awareness affects results), ordering, pagination, or potential side effects. There is no mention of permissions or limits beyond the schema's default, leaving behavioral 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 a single, efficient sentence that conveys the core action and a distinguishing feature without any redundancy or filler. It is immediately scannable and front-loaded.

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

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

Despite full schema coverage, the absence of an output schema places a burden on the description to explain return values and behavioral semantics, which it does not. The description also lacks guidance on edge cases and the exact interplay between topic and branch awareness, making it incomplete for an agent to fully understand expected results.

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 provides 100% parameter descriptions, so the baseline is 3. The description adds minimal value by relating 'topic' to the primary search key and 'branch awareness' to the git_branch filter, but it does not enrich parameter meaning beyond the schema definitions.

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

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

The description states 'Get memories by topic' with a clear verb and resource, and 'branch awareness' signals the git_branch filter, differentiating it from generic memory search tools like memory_search or search_memories. However, it does not explicitly name these siblings or define how branch awareness works, so it stops short of a perfect 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?

There is no explicit statement about when to use this tool versus alternatives, nor any exclusions. The phrase 'by topic with branch awareness' implies a specific use case (topic-based retrieval with branch filtering), but the absence of named alternatives like memory_search or search_memories leaves the selection heuristic fuzzy.

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 responsibility for disclosing behavior. It does not mention that the operation is read-only, how pagination works, or any potential side effects. The only behavioral hint is the name and the word 'Get', which 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 a single concise sentence with a clear verb and object. Every word contributes to the purpose, and there is no extraneous information.

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

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

Given the lack of annotations, no output schema, and the presence of many similar sibling tools, the description is too minimal. It does not explain what 'entities' are, what the response looks like, or how this tool differs from memory search or retrieval tools. An agent may struggle to select this tool correctly without additional 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 schema description coverage is 100%, so both parameters (limit and entity_type) are already documented in the schema. The description adds no additional meaning beyond the schema, but it doesn't mislead about the parameters either. The word 'all' may slightly conflict with the limit default, but this is a minor issue.

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 retrieves extracted entities from memories, using a specific verb and resource. It is distinguishable from sibling tools like memory_search or get_memory by its focus on 'entities', though it doesn't explicitly differentiate itself from those alternatives.

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 memory_search or search_semantic. It simply states what it does without any contextual or exclusionary hints.

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 only says 'Retrieve' which implies a read operation, but does not mention return format, error behavior, or whether filters affect the response. Minimal context added beyond the verb.

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 one sentence with no filler. Every word is useful and it is front-loaded with the key action and resource.

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?

There is no output schema, and the description does not explain what the tool returns. It lacks context about the nature of 'conventions' or the effect of optional filters, leaving the agent with an incomplete picture for a simple retrieval task.

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 each parameter already described. The description adds no additional parameter meaning, so the baseline of 3 is appropriate.

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

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

The description clearly states the tool retrieves project conventions, using a specific verb and resource. It doesn't explicitly distinguish from sibling tools, but the verb 'Retrieve' makes the direction clear relative to learn_project_convention.

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?

There is no guidance on when to use this tool versus alternatives. No context is provided about scenarios where this tool is appropriate, nor any mention of sibling tools like learn_project_convention or store_conventions_batch.

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, and the description adds almost no behavioral disclosure. It does not state whether the tool is purely read-only, what the response looks like, whether there are rate limits or authentication requirements, or what 'categories' are referenced in the schema. The description is too thin to convey expected behavior beyond a simple read operation.

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

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

The description is a single, concise sentence with no filler or redundant content. It is front-loaded with the action and resource, making it easy to scan. Every word adds some value, even the 'debugging purposes' clause provides a usage hint.

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 one optional parameter, no output schema, and no annotations, the description carries the burden of explaining what 'activity' means and what the tool returns. It fails to do so, leaving the agent guessing about the result format or the scope of activity. The description is too 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?

The input schema fully documents the only parameter ('limit' with a description and default). The description adds no additional semantic information about the parameter. With 100% schema coverage, the baseline of 3 is appropriate, as the schema does the heavy lifting.

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

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

The description states a clear verb ('get') and a resource ('recent activity'), but 'activity' is vague and does not specify what kind of activity (e.g., user actions, system events). It does not distinguish itself from sibling tools like 'get_interaction_history' or 'get_artifact_reads', which likely also return recent activity. The debugging hint is the only differentiator, but the core resource remains ambiguous.

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

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

The phrase 'for debugging purposes' implies a use case but is not specific. There is no explicit guidance on when to use this tool versus alternatives, no exclusions, and no clear scenarios. It provides minimal context but falls short of clear usage instructions.

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 of behavioral disclosure. It only says 'Get' which implies a read operation, but does not confirm read-only safety, return value structure, pagination behavior, or any potential side effects. This is a significant gap for a tool with no annotation safety signals.

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

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

The description is a single concise sentence that front-loads the action and object. There is zero wasted wording.

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

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

Given no output schema and no annotations, the description provides minimal context about what is returned (only 'with confidence scores') and nothing about ordering, defaults, or how the parameters interact. For a simple list/read tool with only two optional numeric parameters, this may be adequate, but it still leaves room for more detail.

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 limit and min_confidence clearly documented in the input schema. The description adds no information about these parameters, so it neither helps nor hinders; the baseline of 3 is appropriate given full schema coverage.

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

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

The description clearly states the action (get) and the resource (learned routing patterns) and includes the key detail of confidence scores. It is clear but does not explicitly distinguish itself from sibling tools like find_similar_routing_patterns or search_patterns, though the word 'learned' hints at a distinction.

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

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

The description provides no guidance on when to use this tool versus alternatives such as store_routing_pattern or find_similar_routing_patterns. It does not mention use cases, exclusions, or relationships to other routing-pattern tools.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only mentions retrieval and optional filtering, without noting return format, read-only nature, default limits (beyond schema), or any side effects. This is a significant 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?

The description is a single concise sentence that is easy to parse. It front-loads the verb and resource without unnecessary words. However, it may be too terse for the amount of information an agent needs, but structural conciseness itself is good.

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

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

The tool has no output schema and sparse annotations, so the description should compensate by describing return values or usage context. It does neither. For a simple retrieval tool this is a clear deficiency, leaving the agent without key information such as what the response looks like.

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

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

All four parameters are fully described in the schema (100% coverage), so the baseline is 3. The description adds no extra semantic value beyond saying 'optional filtering'.

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 retrieves tasks with optional filtering, which identifies the action and resource. However, it doesn't differentiate from sibling task-related tools like task_board or other retrieval tools, though the name 'get_tasks' is self-explanatory.

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 such as delete_task, update_task, or task_board. The description only states what it does without any context for selection.

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

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

No annotations are provided, and the description does not disclose behavioral traits such as read-only status, output format, or potential side effects. It only states the return value, omitting important context about 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 one concise sentence with no filler words. It effectively front-loads the purpose and is appropriately sized for a simple 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?

The description conveys the basic function and is adequate for a simple tool with one optional parameter and no output schema. However, it would benefit from explaining what 'tool manifest' includes or who would use this tool, making it slightly incomplete for a meta-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 single parameter include_schemas is fully described in the input schema with a default value, so schema coverage is 100%. The description's mention of 'required-args schemas' aligns with the parameter but adds no new semantic meaning beyond what the schema already provides.

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

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

The description clearly states the tool returns a machine-readable tool manifest and required-args schemas, using a specific verb and resource. It does not explicitly distinguish it from similar sibling tools like list_api_specs or get_api_spec, but it is specific enough to convey the core 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?

No guidance is provided on when to use this tool versus alternatives. It does not mention typical use cases, prerequisites, or exclusions, leaving the agent to infer when to invoke it.

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

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

With no annotations, the description must carry the full burden of behavioral disclosure. It only says 'retrieve', implying a read operation, but does not disclose behavior with optional params, default resolution, failure cases, or return 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 extremely concise, but it is borderline tautological, adding little value over the tool name. It is not bloated, yet it is under-specified, lacking the depth expected for a tool with multiple optional parameters.

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 output schema and no annotations, the description provides minimal context. For a tool with two optional parameters, more information about behavior or return structure is needed to fully complete the picture.

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

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

Schema coverage is 100%, so both parameters are fully documented in the input schema. The description adds no parameter semantics beyond the baseline established by the schema.

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

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

The description clearly states the action (retrieve) and resource (user preferences), but it does not differentiate from related tools like track_user_preference or get_interaction_history. While clear, it lacks the specificity to distinguish it from siblings.

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 such as track_user_preference or memory_search. The description offers no context, exclusions, or prerequisites, leaving the agent to infer usage solely from the name.

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 responsibility for disclosing side effects. It states 'store', implying persistence, but does not explain overwrite behavior, idempotency semantics (despite an idempotency_key parameter), or any preconditions. This is a significant gap for a write operation.

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

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

The description is a single concise sentence with no wasted words, which is positive. However, for a 6-parameter tool with no annotations or output schema, it is under-specified and lacks structural elements like a note on return values or usage context.

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 (6 parameters, no annotations, no output schema), the minimal description is insufficient. It does not explain what the tool returns, how it handles duplicates, or how it relates to retrieval tools like 'get_project_conventions'. The description alone leaves major 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 input schema provides descriptions for all six parameters (100% coverage), so the baseline is 3. The description adds no additional meaning about parameters; it only repeats the general purpose. No value is added 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 identifies the action ('Learn and store') and the resource ('project-specific conventions'), which is specific enough. However, it does not distinguish from similar sibling tools like 'store_conventions_batch' or 'get_project_conventions', so it lacks explicit differentiation.

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 given on when to use this tool versus alternatives. There is no mention of preferred scenarios, exclusions, or comparison with sibling tools like 'store_conventions_batch' for bulk operations.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the linking action and does not explain whether this is a write operation, whether existing links are overwritten, what prerequisites exist, or what 'resurfacing' entails.

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, front-loaded sentence with no redundant or filler content. Every word adds value, 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?

The tool is simple with fully documented parameters, but the description omits important behavioral details (e.g., whether the memory must already exist, or side effects of the link). With no output schema or annotations, the description is not fully complete for an agent to predict consequences of 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 already provides 100% coverage with basic descriptions ('Project name' and 'Memory row identifier'). The tool description adds no additional parameter semantics beyond the schema, so it neither helps nor hurts the agent's understanding.

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

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

The description clearly identifies the action ('Link') and the objects involved ('a memory to a project'), and adds the purpose 'for operational resurfacing.' It is specific enough to distinguish from sibling memory tools, though it does not explicitly name alternatives.

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

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

The phrase 'for operational resurfacing' implies a use case, but the description gives no explicit guidance on when to prefer this tool over related alternatives like memory_search or project_profile. No exclusions or conditions 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 the full burden of behavioral disclosure. It implies a read-only operation via the verb 'list', but does not explicitly state that it is non-destructive or describe edge cases like empty lists or pagination. The addition of 'with metadata' gives a partial hint about the return format, but underlying behavior details are sparse.

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, fully front-loaded with the action ('List') and object ('all stored API specifications with metadata'). There is no filler or redundant information, making it highly concise and well-structured.

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

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

For a simple, no-parameter list tool, the description is largely complete. It covers what the tool does and hints at the return content (metadata). However, it does not specify what 'metadata' includes or whether the list is exhaustive, and there is no output schema to fill this gap. Slightly more detail would make it fully complete.

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

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

This tool has zero parameters, so the baseline for parameter semantics is 4. The description does not need to explain parameters because there are none, and the empty schema already confirms this. No additional parameter context is needed.

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 'stored API specifications with metadata', which distinguishes it from sibling tools like get_api_spec (retrieve single) and delete_api_spec (delete). The purpose is immediately apparent and unambiguous.

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

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

No explicit guidance is provided about when to use this tool versus alternatives. However, the name 'list_api_specs' and the phrase 'List all' imply it is the go-to for getting an overview of all stored specs. It lacks explicit exclusions or comparisons to related tools like search_api_endpoints, so usage context is only 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?

No annotations are provided. The description implies a mutating operation on storage but does not disclose whether data is deleted, whether the operation is reversible, or what the effect on database performance is. This is insufficient for the agent to judge safety.

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

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

The description is a single concise sentence that is front-loaded with the verb. It is efficient and directly to the point, though it could benefit from a bit more detail without being verbose.

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?

As a standalone description with no annotations, no output schema, and no parameters, it leaves open what exactly is optimized, whether the operation is safe, and what the outcome will be. For a mutating maintenance tool, this is incomplete.

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 zero parameters and the input schema is empty. The description correctly implies no parameters are needed. With 0 params, the baseline is 4 according to the rubric.

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 specific verbs 'Compact' and 'optimize' with resource 'database storage', indicating a maintenance operation distinct from siblings like memory_search or store_memory. However, it is somewhat vague about the exact scope or method of optimization.

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

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

No guidance is provided on when to use this tool versus alternatives. It does not mention that this is a storage maintenance operation, whether it should be run periodically, or any alternatives to consider.

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 disclose behavioral traits. However, it only states the basic action and format, without mentioning whether the operation is read-only, any side effects, rate limits, or authentication requirements. The simple 'export' phrase implies reading, but this is not explicit.

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 immediately conveys the core action and output formats. It is concise without unnecessary words, meeting the criteria for efficient communication.

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 (3 optional parameters, no output schema), the description provides a minimal but adequate overview. However, it lacks information about the return value or any behavioral nuances, and the absence of usage guidelines makes it less complete for an agent unfamiliar with the tool.

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

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

The schema already covers all parameters with descriptions, so the baseline is 3. The description adds minimal semantic value by mentioning the 'format' option, but it does not enrich the meaning of 'limit' or 'context_type' 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 verb 'export' and the resource 'memories', and specifies the two output formats (JSON or Markdown). This distinguishes it from sibling tools like memory_import and memory_search, making the tool's 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 provides no guidance on when to use this tool versus alternatives. There is no mention of scenarios, prerequisites, or exclusions, leaving the agent without context for choosing memory_export over memory_search, memory_import, or other memory-related operations.

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

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

With no annotations, the description carries full behavioral burden but only states the action. It does not disclose the merge/overwrite behavior, duplicate handling, or session association beyond what the schema already specifies.

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

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

The description is a single concise sentence of five words with no filler. It is front-loaded and easily parseable.

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 an import mutation tool with no annotations and no output schema, this description is too sparse. It lacks information about batch processing, conflict resolution, return values, and side effects, making it incomplete for an agent to invoke 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 covers 100% of parameters with descriptions, so baseline is 3. The description adds no extra parameter details beyond the word 'JSON', which is already in 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 uses the specific verb 'Import' and the resource 'memories' with format 'JSON', clearly indicating a bulk import action. It inherently distinguishes from sibling tools like memory_export and memory_search, though it doesn't explicitly differentiate from store_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?

There is no guidance on when to use this tool over alternatives such as store_memory or memory_export. No context, exclusions, or alternative tools 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, the description carries the burden of behavioral disclosure. It reveals the search scope and ranking algorithm, but it does not mention whether the operation is read-only, what the result format is, or any potential side effects. This is partial 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 a single sentence that efficiently communicates the tool's purpose and key behavioral details. There is no filler; every term (full-text, all session contexts, FTS5, BM25) 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?

Given the lack of annotations, output schema, and explicit alternatives, the description is moderately complete. It defines the scope and ranking but does not address return structure, filtering nuances, or how it relates to the many sibling search tools, leaving some gaps for the agent to resolve.

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

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

All three parameters are fully described in the input schema (100% coverage), and the description adds no additional parameter-level detail. The baseline of 3 applies because the schema handles 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 action ('Full-text search') and the resource ('all session contexts'), and specifies the method ('FTS5 with BM25 ranking'). This distinguishes it from sibling tools like search_semantic or search_temporal, which target different search modes.

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 keyword-based full-text search across all session contexts, but it does not explicitly mention when to avoid it or point to alternatives. The context is clear enough for an informed agent, but explicit guidance is missing.

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 responsibility for behavioral disclosure. It only states 'Manage tags' without revealing side effects, required conditions, return values, or effects of the 'add' and 'list' actions. This is a significant transparency gap for a tool that performs mutations (add) and queries (list).

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 a single sentence that lacks necessary detail. While it avoids redundancy, it under-specifies the tool's behavior, making it minimally useful despite its brevity.

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 4 parameters, no output schema, and no annotations, the description is severely incomplete. It does not convey the tool's purpose beyond a generic phrase, leaving critical behavioral and usage information absent.

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

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

Schema description coverage is 100%, so all parameters are already well-documented in the schema. The description adds no additional parameter semantics, but the baseline of 3 is appropriate since the schema does the heavy lifting.

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

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

The description 'Manage tags for memory entries' identifies the resource (tags for memory entries) but uses the vague verb 'manage' without specifying the actions available (list, add) that are defined in the schema. It does not clearly distinguish this tool from siblings, though no other tag-specific tool exists, providing minimal differentiation.

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 offers no guidance on when to use this tool versus alternatives. It lacks context for when to invoke it, prerequisites (e.g., memory_id for add), or exclusions. Users must infer usage entirely from the schema.

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 burden of explaining side effects, mutability, or prerequisites. It does not disclose that actions like 'create' will write data, whether 'get' is read-only, or what happens on error. This leaves the agent without critical behavioral context.

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 short sentence with no fluff, but it is under-specified to the point of conveying little actionable information. It is concise in form but sacrifices clarity, so it does not earn a higher score.

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

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

The tool has 7 parameters, 3 possible actions, no output schema, and no annotations, yet the description provides no information about action-specific requirements, return values, or usage scenarios. It is inadequate 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?

Schema description coverage is 100%, so all parameters (id, name, action, root_path, frameworks, etc.) are already documented in the schema. The description adds no additional meaning beyond 'manage project profiles', so the baseline score of 3 is appropriate.

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

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

The description identifies the resource (project profiles) and a general intent (manage), but the verb 'manage' is vague and does not specify the concrete operations (get, create, list) that the schema reveals. It does not distinguish itself from sibling tools like get_project_conventions or learn_project_convention, though it is not a pure tautology.

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?

There is no guidance on when to use this tool versus alternatives. The description only says 'manage project profiles for multi-project support' without mentioning which actions require what context or when a sibling tool would be more appropriate.

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 only mentions 'query by keyword' without disclosing whether the operation is read-only, how results are sorted, or any limitations. This minimal disclosure may be sufficient for a simple query, but it lacks detail about behavior beyond the basic action.

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

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

The description is a single concise sentence with no redundant information. It is efficient and front-loaded.

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

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

Despite the simple schema, the tool sits among many similar search tools, and the description does not explain what distinguishes keyword search from semantic, temporal, or pattern search. No output schema is present, so return behavior is also unexplained. This makes the description insufficient for confident selection.

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 (query and limit). The description adds no additional context about parameter meaning or formatting, meriting the baseline score.

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 ('Query') and resource ('memory records') with a keyword method. However, it does not differentiate from sibling tools like memory_search or search_semantic, which likely overlap in 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?

No guidance is provided on when to use this tool versus the numerous sibling search tools (memory_search, search_semantic, search_patterns, etc.). The description implies keyword-based search but offers no exclusions or 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?

With no annotations provided, the description must carry the full burden of behavioral disclosure. It implies a write operation through the verb 'Record' but does not disclose side effects, idempotency, whether it appends to a log, or any permission requirements. The description also conflates 'injected' and 'consulted' without explaining if these produce different outcomes.

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

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

The description is a single, concise sentence of 12 words. It is front-loaded with the verb and resource, contains no filler or redundancy, and every word contributes to the core meaning.

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 8 parameters, no annotations, and no output schema, the description is too sparse to be fully useful. It does not explain the tool's role in the broader workflow, what happens after recording, or the significance of the recorded event. The schema covers parameter syntax, but the description still lacks guidance on how and when to use this tool effectively.

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

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

The input schema has 100% parameter description coverage, so each of the 8 parameters is individually documented. The description adds minimal context by specifying the artifact is 'durable on-disk', which reinforces the meaning of 'artifact_path'. However, it does not elaborate on how parameters like 'query', 'score', or 'metadata' are used together, nor does it add value beyond the schema's own descriptions.

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

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

The description uses the specific verb 'Record' with a clear resource ('durable on-disk memory artifact') and indicates the action (injected or consulted). It distinguishes this tool from retrieval siblings like 'get_artifact_reads' or 'memory_search' by focusing on the recording of an event. However, it does not explicitly differentiate from other recording tools like 'store_interaction' or 'store_session_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 does not mention exclusions, prerequisites, or context in which this recording should occur. The single sentence merely states what the tool does, leaving the agent without decision support for tool selection.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states 'retrieve' without explaining wildcard behavior for session_id, default limits, auth requirements, or what 'stored session context' includes. This is a significant gap for a tool with five parameters.

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

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

The description is a single sentence with no verbosity or fluff, making it appropriately concise and front-loaded. It earns its place by clearly naming the operation, though it lacks detail. It is not under-specified to the point of being a tautology, but it is minimal.

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

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

The tool has five parameters, one required, and no output schema, yet the description provides no context about return values, wildcard behavior, filtering, or how it relates to store_session_context and update_session_context. The description is too sparse to be fully usable in a complex 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%, as every parameter (key, limit, session_id, context_key, context_type) has a description in the input schema. The description adds no additional parameter semantics beyond what the schema already provides, so the baseline of 3 is appropriate.

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

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

The description 'Retrieve stored session context' clearly identifies the verb (retrieve) and resource (session context), making the core purpose understandable. However, it does not distinguish this from sibling tools like memory_search, search_semantic, or get_recent_activity, all of which could also retrieve something. It is clear but lacks differentiation.

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 does not mention any prerequisites, scenarios, or exclusions. Users are left to infer usage from the name alone, which is insufficient given the similar sibling tools.

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

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

With no annotations provided, the description carries the full burden for behavioral disclosure. However, it only says 'Full-text search across API endpoints' and does not mention that it is a read-only operation, the structure of results, or how parameters like limit and spec_id affect behavior. This is a significant gap for a tool with no output schema.

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

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

The description is a single, concise sentence with no wasted words. It is front-loaded with the core action and resource. However, it is so terse that it omits useful context, though this is more a completeness issue than a conciseness issue.

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 no output schema and no annotations, the description is incomplete. It fails to explain what a full-text search returns, how results are ordered or filtered, or how the agent can use the limit and spec_id parameters effectively. This is below the minimum viable level for a no-output-schema 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 100% coverage, describing all three parameters (query, limit, spec_id) with clear semantics. The tool description adds no additional parameter context, so the baseline of 3 is appropriate because the schema already handles parameter documentation effectively.

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

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

The description clearly states the tool's function with a specific verb ('search') and resource ('API endpoints'), making its purpose evident. It distinguishes itself from sibling search tools by targeting API endpoints, though it doesn't explicitly contrast with related tools like get_api_endpoints or get_api_endpoint_detail.

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 other search tools (e.g., search_semantic, search_patterns, search_temporal) or retrieval tools (e.g., get_api_endpoints). It does not mention any prerequisites, exclusions, or recommended contexts, leaving the agent to infer 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 provided, the description carries the full burden for behavioral disclosure, yet it only states the basic action. No details about search semantics, ordering, pagination, or limitations are given.

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 no redundancy. It immediately communicates the tool's purpose without 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?

The tool has no annotations and no output schema, and the description is too sparse to compensate. It omits important context about how full-text search behaves, what results look like, and how it relates to the many sibling search tools.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-specific meaning beyond what the schema already documents, which is acceptable given the complete 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 uses a specific verb ('search') and resource ('memories') with qualifiers ('full-text', 'all') that clearly distinguish it from semantic, pattern, and temporal sibling search tools. It unambiguously states the tool's core function.

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 over sibling search tools like search_semantic or memory_search. It lacks any mention of appropriate use cases or exclusions, leaving the agent to infer from 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. 'Detect' implies a read-only operation, but the description does not disclose behavioral traits such as whether results are sorted, how patterns are defined, or whether any memory state is modified. It lacks side-effect information, permission requirements, or return 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 single concise sentence with no unnecessary words, front-loading the core purpose. However, it is extremely minimal, bordering on under-specification, which slightly reduces the score from 5.

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 three parameters, no annotations, no output schema, and many sibling search tools, a one-sentence description is insufficient. It does not explain how patterns are detected, what the output looks like, or when to prefer this over other search tools, leaving the agent with significant 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 input schema descriptions cover all three parameters (context_type, pattern_types, min_occurrences) at 100% coverage, so the description adds no additional parameter semantics. Per the rubric, baseline of 3 applies since 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 provides a clear verb 'Detect' and a specific resource 'memory content' with the object 'recurring patterns', which clearly states the tool's function. It does not explicitly differentiate from sibling search tools like memory_search or search_semantic, but the focus on patterns is distinct.

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?

There is no guidance on when to use this tool versus alternatives such as memory_search or search_temporal. The description implies it is for detecting patterns but does not provide exclusions, prerequisites, or 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?

With no annotations, the description bears the full burden of disclosure. It only mentions a dependency (@xenova/transformers) and implies a read operation, but does not explain return format, side effects, or any limitations.

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 single-sentence description is technically concise, but it provides minimal substance. It earns its place only for the dependency note, yet lacks the detail a tool description should offer.

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 severely incomplete: no mention of the search target, result behavior, or any prerequisites beyond the library. Without annotations or an output schema, this is insufficient for an agent to use safely.

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?

Input schema already covers all three parameters with clear descriptions (query, limit, threshold), so the description adds no extra meaning. Baseline high coverage warrants a 3.

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 'Semantic similarity search' essentially restates the tool name without specifying what data is searched. It lacks a clear resource or scope, making it hard to distinguish from siblings like memory_search or search_temporal.

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 vs alternatives. The description only mentions a library dependency, not the appropriate use case or selection criteria among the many search-like tools.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does not state whether the tool is read-only, how data is returned, whether it aggregates or lists, or any side effects. The phrase 'analyze memory patterns' is too high-level and provides no additional behavioral context.

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

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

The description is a single sentence with no filler. It is front-loaded with the verb and resource. However, it is slightly generic, which reduces its utility, but as a concise statement it 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?

No output schema, no annotations, and no description of return values or aggregation behavior. The description is not complete enough for an agent to confidently use the tool beyond knowing it analyzes memory over time. It lacks context about what 'memory patterns' means or how to interpret results.

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 each parameter already has a clear description. The tool description adds minimal meaning beyond confirming the temporal nature via 'over time periods', which maps to start_date, end_date, and period_type. Baseline 3 is appropriate as the schema does the heavy lifting.

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

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

The description 'Analyze memory patterns over time periods' clearly states the action (analyze) and resource (memory patterns) with a temporal scope. It is coherent and matches the tool name, but it does not explicitly differentiate from sibling search tools like search_semantic or search_patterns beyond the temporal angle.

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

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

There is no guidance on when to use this tool versus alternatives. No mention of ideal scenarios, prerequisites, or exclusions. The description only states the function, leaving the agent to infer usage from the name.

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 of behavioral disclosure. It states the tool checks health and connectivity but does not disclose whether it is read-only, potential side effects, or any resource costs. The parameter schema mentions integrity checks, but the main description adds no behavioral context beyond the basic action.

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, focused sentence with no filler words. It effectively communicates the core purpose in the fewest words possible, 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?

For a simple health check tool with two optional boolean parameters, the description is adequate but leaves gaps: it does not specify what the response contains, how failures are indicated, or any timeouts. Since there is no output schema, a little more detail about the return value would improve 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?

Schema description coverage is 100%, with both parameters (include_stats, include_integrity) fully described in the input schema. The description does not add parameter information, but the baseline of 3 applies because the schema already handles parameter semantics adequately.

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 the specific verb 'Check' and identifies the resource as 'MCP server health and database connectivity', which clearly conveys the tool's scope. It distinguishes from sibling tools like 'server_stats' by focusing on health and connectivity rather than metrics, though it does not explicitly name alternatives.

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?

There is no guidance on when to use this tool versus alternatives such as 'server_stats' or other diagnostic tools. The description simply states the function without providing context on appropriate use cases, 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, the description carries the full burden for behavioral transparency. It only restates the purpose and offers no information about side effects, permissions, rate limits, or return format. The word 'detailed' suggests depth but does not disclose what that entails.

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

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

The description is a single, concise sentence that communicates the core purpose without superfluous wording. It is appropriately sized for a simple tool with one optional parameter.

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

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

The tool is relatively simple with one optional parameter and no output schema, so the description meets the minimum bar. However, it lacks context on what specific statistics are included, how 'performance metrics' differ from health checks, or what the response structure looks like, leaving room for 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 already provides complete documentation for the single parameter 'include_performance' with its default value. The description mentions 'performance metrics' which aligns with the parameter, but adds no extra semantic detail beyond what the schema offers, so a baseline of 3 is appropriate.

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

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

The description clearly states the verb 'get' and the resource 'server statistics and performance metrics', making the primary purpose evident. However, it does not explicitly distinguish from the sibling tool 'server_health', which likely covers health status, so differentiation is only implicit.

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 'server_health' or 'get_autodream_metrics'. The description implies it is for detailed stats but does not state exclusions or specific scenarios, leaving the agent without decision support.

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 disclose behavioral traits. It does not state whether the scan is read-only, whether it modifies any state, what 'resurfaced' means as an outcome, or any side effects. The behavior is underspecified.

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 nine words, front-loaded with the verb 'Scan'. It is efficient and free of filler, though its brevity comes at the cost of 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?

For a tool with one optional parameter, no annotations, and no output schema, the description is insufficient. It does not explain what constitutes stale work, what the output format is, or how it relates to sibling tools like daily_briefing or weekly_review.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds no additional meaning to the 'stale_hours' parameter beyond what the schema already specifies; the schema's description is sufficient on its own.

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 'scan' and identifies the resource as 'stale work' with a purpose ('should be resurfaced'), clearly stating what the tool does. However, it doesn't distinguish from siblings like task_insights or weekly_review that might also surface stale work, so it is not 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?

No guidance is provided on when to use this tool versus alternatives. There is no mention of prerequisites, triggers, or exclusions. The description only states the action, leaving the caller without context on when this scan is appropriate.

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 mentions 'parse' which gives a hint of behavior beyond storage, but it does not disclose side effects like overwriting existing specs, validation behavior, or return format. For a store operation, this leaves important behavioral questions unanswered.

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

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

The description is a single sentence with no filler words. It is front-loaded with the action verb and directly states the resource. Every word earns its place, making it exceptionally concise and well structured for such a short description.

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 and the schema's complete parameter coverage, the description is minimally viable. However, it omits any mention of what happens after parsing, whether the spec is upserted or duplicates are rejected, and there's no output schema to fill these gaps. For a CRUD-style store tool, this is adequate but not richly contextual.

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 provides 100% coverage with descriptions for all parameters, so the description does not need to explain them. The tool description adds no additional parameter semantics, so the baseline of 3 is appropriate.

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

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

The description 'Store and parse OpenAPI/Swagger specification' uses specific verbs ('store', 'parse') and a specific resource, clearly distinguishing it from sibling tools like get_api_spec or list_api_specs. It conveys the core function without ambiguity.

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 the tool is used when you want to persist and process an OpenAPI/Swagger specification, but it does not explicitly state when to use it versus alternatives (e.g., storing session context or memory). No exclusions or alternative references are provided.

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 mentions 'single transaction' and performance, but does not disclose error handling, partial failure behavior, overwrite semantics, or what the tool returns. This is minimal disclosure for a write operation without annotation support.

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, front-loaded sentence containing only essential information: the action, target, transactionality, and performance benefit. No unnecessary words or repetition.

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

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

For a batch storage tool with no output schema and no annotations, the description covers core purpose and a key behavioral trait (transaction). However, it does not explain return values, failure scenarios, or how idempotency_key works in practice, leaving moderate 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 coverage is 100%, so the input schema already describes each parameter (contexts, session_id, idempotency_key) adequately. The description adds no parameter-specific semantics beyond hinting at batch storage, so the baseline score applies.

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

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

The description clearly states the verb 'Store' and the resource 'multiple session contexts'. It distinguishes itself from the sibling tool 'store_session_context' by emphasizing batch operation and 'single transaction', 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 when storing multiple contexts, especially for performance ('40-60% faster'). However, it does not explicitly state when to use this tool versus 'store_session_context' or mention any exclusions or alternative selection criteria.

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 transparency burden. It does disclose an important trait (single transaction, implying atomicity) and a performance characteristic. However, it omits details about failure handling, overwrite/conflict semantics, and return values, which are relevant for a storage 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, front-loaded sentence that states the action and a key benefit. It is entirely free of redundancy and well-structured for quick parsing.

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 schema covers parameters well, but there is no output schema and the description does not mention return values or idempotency behavior. It also lacks explicit references to sibling tools for differentiation, leaving some contextual gaps for a moderately complex storage 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?

All parameter descriptions in the schema already provide complete coverage, so the description adds no extra meaning. It does not elaborate on how parameters interact or any constraints beyond what the schema states, justifying the baseline score.

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'), the resource ('multiple conventions'), and the batch nature implied by both the name and the phrase 'in a single transaction'. It distinguishes itself from sibling tools like learn_project_convention by focusing on batch 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 communicates when to use the tool: when storing multiple conventions atomically, with a performance benefit. However, it does not explicitly reference alternative tools for single-convention storage or state exclusions, leaving some implied guidance rather than fully explicit.

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 transparency burden. It only says 'store' without disclosing write behavior, idempotency, auth requirements, or how metadata/idempotency_key affect the operation. The schema mentions idempotency_key, but its behavioral implications are not explained.

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, front-loaded sentence with no filler. It efficiently communicates the core action and purpose, though it skips details that other dimensions capture.

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 5 parameters, a nested object, no output schema, and many closely related sibling tools, the description is too thin. It omits return values, idempotency semantics, and any relationship to session context storage, leaving the agent without 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?

Schema description coverage is 100%; all five parameters, including metadata and idempotency_key, have meaningful descriptions in the schema. The tool description adds no additional parameter semantics, so the baseline of 3 applies.

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

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

The description 'Store a conversation interaction for context' clearly identifies the action (store) and resource (conversation interaction), with a purpose ('for context'). It is unambiguous but does not differentiate from sibling tools like store_session_context or store_contexts_batch, which also store context-related 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 on when to use this tool versus the many sibling store/context tools. The description gives no conditions, preconditions, or exclusions, leaving the agent to infer usage from 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?

With no annotations, the description must carry the full transparency burden. It implies a write operation but fails to disclose key behaviors like overwrite semantics, permission requirements, or side effects on existing memories.

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 that front-loads the action and key features, with no filler or redundancy. While concise, it sacrifices detail about parameters and behavior.

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

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

The tool has 7 parameters, 3 required, and no output schema, making context important. The minimal description does not explain return values, error conditions, or relationships with other memory tools, leaving significant gaps for an 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 each parameter is already documented. The description's reference to branch awareness, type classification, and importance level aligns with the schema's git_branch, memory_type, and importance parameters but adds little beyond what the schema already provides.

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

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

The description clearly states the action 'Store' on 'a memory' and highlights three notable features (branch awareness, type classification, importance level). However, it does not distinguish this tool from similar siblings like store_session_context or store_interaction, so it misses the full 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 its many memory-related siblings. It neither mentions specific use cases nor excludes alternatives, leaving the agent to infer applicability.

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?

There are no annotations, so the description carries the full burden. It implies a write operation but does not disclose key behaviors such as whether the pattern_key must be unique, whether existing patterns are overwritten, or any side effects. The description provides no behavioral context beyond the basic action.

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, succinct sentence that conveys the core purpose without unnecessary words. It is well-structured and easy to parse, though it is perhaps too sparse to cover the full complexity of the 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 no annotations, no output schema, six parameters including a nested metadata object, and a complex domain (routing patterns), the description is far too minimal. It does not explain return values, error conditions, or how this tool fits into the broader workflow of storing and retrieving patterns, leaving the agent under-informed.

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 provides 100% coverage of parameter descriptions, so the baseline is 3. The description does not add any parameter semantics beyond the schema, but since the schema is self-explanatory (e.g., pattern_key, agent_name, confidence), a 3 is appropriate.

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

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

The description clearly identifies the action ('Store') and the resource ('successful routing pattern'), with a purpose ('cross-workflow learning'). It distinguishes from read-only pattern retrieval siblings but does not differentiate from other storage tools like store_session_context or store_contexts_batch, so it's not 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?

No guidance is provided on when to use this tool versus alternatives. With many storage-related sibling tools (store_session_context, store_contexts_batch, etc.), the description does not explain when storing a routing pattern is appropriate or when another store tool should be used instead.

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