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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions that the tool 'returns content with metadata annotations' and 'demonstrates MCP annotation capabilities,' which gives some context about output behavior. However, it lacks details on side effects, error handling, or performance characteristics like rate limits or authentication needs, leaving gaps for a tool that modifies content presentation.

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

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

The description is front-loaded with the core purpose in the first sentence, followed by clear sections for Args and Returns. Each sentence adds value without redundancy, making it efficient and well-structured for quick understanding by an AI agent.

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

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

Given the tool's moderate complexity (2 parameters, no annotations, but an output schema exists), the description is reasonably complete. It explains the tool's purpose, parameters, and return behavior. Since an output schema is present, the description doesn't need to detail return values, but it could benefit from more behavioral context or usage scenarios to fully guide the agent.

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

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

The description adds meaningful context beyond the input schema, which has 0% description coverage. It explains that 'messageType' determines the type of message ('error', 'success', or 'debug') and 'includeImage' controls whether an example image is included. This clarifies the purpose and usage of parameters, compensating well for the lack of schema descriptions, though it doesn't detail format or constraints beyond the enum.

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

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

The description clearly states the tool's purpose: 'Demonstrates different annotation patterns for MCP tool responses. Returns content with metadata annotations based on the message type.' It specifies the verb ('demonstrates'), resource ('annotation patterns'), and scope ('MCP tool responses'), though it doesn't explicitly differentiate from sibling tools like 'structuredContent' or 'echo' which might also involve content formatting.

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 mentions the purpose but doesn't specify scenarios, prerequisites, or exclusions. For example, it doesn't clarify if this is for testing, debugging, or production use, or how it differs from siblings like 'structuredContent' that might handle similar tasks.

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 'any configured prefix' which adds useful context about potential message transformation. However, it doesn't disclose important behavioral traits like whether this is a read-only operation, if it has side effects, rate limits, or authentication requirements. The description is minimal but doesn't contradict any annotations.

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

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

The description is extremely concise and well-structured with clear sections for purpose, arguments, and returns. Every sentence earns its place - the first states the purpose, the second explains the parameter, and the third describes the return behavior. No wasted words 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 simple echo tool with 1 parameter and an output schema, the description is reasonably complete. It explains what the tool does, what the parameter means, and what to expect in return. The presence of an output schema means the description doesn't need to detail return values. However, it could benefit from more context about when to use this versus similar siblings.

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

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

With 0% schema description coverage and only 1 parameter, the description adds meaningful context by explaining that 'message' is 'The message to echo'. This provides semantic understanding beyond the bare schema. However, it doesn't elaborate on message format constraints, length limits, or special characters that might be relevant.

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

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

The description clearly states the tool's purpose with 'Echo a message back to the client' - a specific verb ('echo') and resource ('message'). It distinguishes from siblings like 'sum' or 'printEnv' by focusing on message echoing. However, it doesn't explicitly differentiate from 'annotatedMessage' which might be a similar sibling.

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. With siblings like 'annotatedMessage' that might serve similar purposes, there's no indication of when 'echo' is preferred or when other tools should be used instead. No context about appropriate use cases is 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 provided, the description carries the full burden of behavioral disclosure. It specifies the resource ID range constraint (1-100) and hints at the return format ('A list containing...'), which adds some context beyond basic purpose. However, it lacks details on error handling, performance, or side effects, leaving gaps for a tool that returns references.

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

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

The description is well-structured and concise: it opens with the core purpose, specifies the key constraint, and uses clear sections ('Args:', 'Returns:') to organize information. Every sentence adds value without redundancy, making it easy to parse and front-loaded with essential 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?

Given the tool's low complexity (1 parameter, no nested objects) and the presence of an output schema (which handles return values), the description is reasonably complete. It covers purpose, parameter semantics, and high-level return structure. However, it could benefit from more behavioral context (e.g., error cases) to fully compensate for 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?

The description adds significant meaning beyond the input schema, which has 0% description coverage. It explains that 'resourceId' is the 'ID of the resource to reference' and specifies the valid range (1-100), clarifying semantics that the schema alone doesn't provide. With only one parameter, this compensation is effective, though not exhaustive.

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

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

The description clearly states the tool's purpose: 'Returns a resource reference that can be used by MCP clients to fetch a resource.' It specifies the verb ('Returns'), resource ('resource reference'), and high-level utility ('used by MCP clients to fetch a resource'). However, it doesn't explicitly differentiate this tool from its siblings like 'getTinyImage' or 'structuredContent', which might also return references or resources.

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 minimal usage guidance: it mentions the resource ID must be between 1 and 100, but offers no context on when to use this tool versus alternatives like 'listRoots' or 'getTinyImage'. There's no mention of prerequisites, typical scenarios, or exclusions, leaving the agent to infer usage from the purpose alone.

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

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

No annotations are provided, so the description carries the full burden. It discloses the return format ('base64-encoded 1x1 PNG image as image content'), which is useful behavioral context. However, it does not mention other traits like performance, error handling, or dependencies, leaving some gaps in 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 front-loaded with the core purpose in the first sentence, followed by a concise explanation of the return value. Both sentences earn their place by providing essential information without redundancy, making it efficient and well-structured.

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

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

Given the tool's simplicity (0 parameters, output schema exists), the description is largely complete, covering purpose and return format. However, with no annotations, it could benefit from more behavioral context (e.g., idempotency or side effects), though the output schema reduces the need for return value details.

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

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

The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description appropriately focuses on output semantics, adding value by explaining the return format beyond what the output schema might provide, though it doesn't detail parameters (as there are none).

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 explicitly states the tool's purpose: 'Returns a small test image to demonstrate image content in MCP tool responses.' This clearly specifies the verb ('Returns'), resource ('small test image'), and distinct purpose ('demonstrate image content'), differentiating it from sibling tools like echo or sum that handle text or calculations.

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

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

The description provides clear context for when to use this tool: for testing or demonstrating image content in responses. However, it does not explicitly state when not to use it or name alternatives among siblings (e.g., getResourceReference might be for other resource types), so it lacks full exclusion guidance.

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

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

With no annotations provided, the description carries the full burden. It discloses the return behavior (formatted list or indication of no support) which is valuable, but doesn't mention error conditions, performance characteristics, or whether this operation has side effects. It provides basic behavioral context but lacks depth.

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 efficiently structured with three sentences: purpose statement, definition of roots, and return behavior. Each sentence adds essential information with zero wasted words, and the most important information (what the tool does) is 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?

Given the tool has an output schema (which handles return value documentation) and only one optional internal parameter, the description provides adequate context. It explains what roots are and what to expect in terms of output format, though it could benefit from mentioning typical use cases or limitations.

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

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

The description mentions no parameters, which aligns with the single optional 'ctx' parameter that has 0% schema description coverage. Since the tool effectively has zero meaningful parameters for the user (ctx is an internal injection mechanism), the description appropriately focuses on the tool's purpose rather than parameter details.

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

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

The description clearly states the specific action ('Lists') and resource ('current MCP roots'), and distinguishes this from siblings by specifying it's about filesystem/URI boundaries exposed by the client. It provides a precise verb+resource combination with clear scope.

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

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

The description provides no guidance on when to use this tool versus alternatives. While it explains what roots are, it doesn't indicate scenarios where this tool should be selected over other sibling tools or mention any prerequisites for usage.

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

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

With no annotations provided, the description carries the full burden. It discloses key behavioral traits: it's a long-running operation with progress notifications, which implies it may take time and provide intermediate updates. However, it doesn't specify whether it's safe, reversible, has side effects, or requires specific permissions. The mention of 'progress notifications' is helpful but incomplete.

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 appropriately sized and front-loaded with the main purpose. The Args and Returns sections are structured clearly. However, the 'ctx' parameter omission reduces efficiency, and the description could be more concise by integrating parameter details more seamlessly.

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 (long-running with progress) and no annotations, the description is moderately complete. It explains the purpose and key parameters but lacks details on behavioral aspects like error handling or side effects. The presence of an output schema means return values are covered, but overall context for safe usage is insufficient.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaningful semantics for 'duration' (total duration in seconds) and 'steps' (number of progress steps), which are not documented in the schema. However, it omits the 'ctx' parameter entirely, leaving it undocumented. The description partially compensates but has a significant gap for one parameter.

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

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

The description clearly states the tool's purpose: 'Demonstrates a long-running operation with progress notifications.' This specifies the verb ('demonstrates') and resource ('long-running operation'), though it's somewhat abstract rather than concrete. It distinguishes from siblings like 'echo' or 'sum' by focusing on progress notifications, but doesn't explicitly differentiate from potentially similar tools.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention any specific scenarios, prerequisites, or exclusions. Given the sibling tools include various utilities, there's no indication whether this is for testing, simulation, or actual 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 indicates this is a read operation ('Prints') and describes the return format, but doesn't mention potential side effects, performance characteristics, or authentication requirements. The description adds basic behavioral context but could be more comprehensive.

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

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

The description is perfectly structured with three concise sentences: purpose statement, usage context, and return format. Every sentence earns its place with no wasted words, and the most important information (what the tool does) comes first.

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

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

Given this is a simple read-only tool with 0 parameters, 100% schema coverage, and an output schema, the description provides exactly what's needed. It explains the purpose, when to use it, and what it returns - no additional complexity requires further explanation.

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

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

The tool has 0 parameters with 100% schema description coverage, so the schema already fully documents the parameter situation. The description appropriately doesn't waste space discussing non-existent parameters. A baseline of 4 is appropriate for zero-parameter tools with 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 clearly states the specific action ('Prints') and resource ('all current environment variables'), making the tool's purpose immediately obvious. It distinguishes itself from sibling tools like 'echo' or 'getResourceReference' by focusing exclusively on environment variables.

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

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

The description provides clear context for when to use this tool ('Useful for debugging server configuration and available environment context'), which helps the agent understand appropriate scenarios. However, it doesn't explicitly state when NOT to use it or name specific alternatives among 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?

No annotations are provided, so the description carries full burden. It mentions the tool 'requests the MCP client to sample from an LLM' but doesn't disclose behavioral traits like rate limits, authentication needs, whether it's read-only or destructive, or how it handles errors. The description adds minimal context beyond the basic operation, leaving significant gaps in behavioral understanding.

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

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

The description is appropriately sized and front-loaded with the core purpose in the first two sentences. The Args and Returns sections are clearly structured. However, the description could be more concise by integrating the parameter explanations more seamlessly rather than as separate bullet points.

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 an output schema (which handles return values) but zero schema description coverage and no annotations, the description provides basic purpose and parameter information but lacks important context. It doesn't explain the 'ctx' parameter's purpose or how this tool relates to sibling LLM-related tools, leaving the agent with incomplete understanding of when and how 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?

Schema description coverage is 0%, so the description must compensate. It documents two parameters ('prompt' and 'maxTokens') with basic semantics, but doesn't mention the third parameter 'ctx' at all. While it adds meaning for the two documented parameters, it fails to address the context parameter, leaving a significant gap in 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 clearly states the tool's purpose: 'Demonstrates LLM sampling capability using the MCP sampling feature. Requests the MCP client to sample from an LLM on behalf of this tool.' It specifies the verb ('sample from an LLM') and resource ('LLM sampling capability'), though it doesn't explicitly differentiate from sibling tools like 'structuredContent' or 'startElicitation' which might also involve LLM interactions.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools or contexts where this sampling tool is preferred over others like 'structuredContent' or 'annotatedMessage'. There's no explicit when/when-not usage advice, leaving the agent to infer based on 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?

No annotations are provided, so the description carries full burden. It discloses key behavioral traits: it's interactive ('requesting structured input from the user'), involves user prompting, and returns a response or error. However, it lacks details on side effects, rate limits, or specific error conditions. The description doesn't contradict any annotations (none exist).

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

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

The description is appropriately sized and front-loaded: the first sentence states the core purpose, followed by explanatory context. The Args and Returns sections are structured but not strictly part of the description text. The prose is efficient with minimal waste, though the explanatory sentence about elicitation could be integrated more tightly.

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

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

Given the tool's moderate complexity (interactive user input), no annotations, and an output schema (which handles return values), the description is partially complete. It covers the purpose and basic behavior but lacks details on the 'ctx' parameter, error handling specifics, and interaction patterns. With output schema present, it doesn't need to explain returns, but other gaps remain.

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

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

Schema description coverage is 0%, so the description must compensate. It documents one parameter ('message') with its default and purpose, but omits the 'ctx' parameter entirely. With 2 parameters total and only 1 described, it adds some meaning but leaves a significant gap (50% coverage), failing to fully compensate for the schema's lack of 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 purpose: 'Demonstrates MCP elicitation by requesting structured input from the user via the MCP client.' It specifies the verb ('requesting structured input') and resource ('user'), and distinguishes it from siblings by focusing on elicitation. However, it doesn't explicitly differentiate from all siblings (like 'annotatedMessage' or 'structuredContent' which might also involve user interaction).

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

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

The description implies usage context: 'Elicitation allows servers to interactively ask users for information during a tool call.' This suggests it's for interactive scenarios, but it doesn't provide explicit when-to-use guidance versus alternatives (e.g., when to use this vs. 'annotatedMessage' or 'structuredContent'). No exclusions or prerequisites are mentioned.

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

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

With no annotations provided, the description carries the full burden. It discloses that the tool returns schema-validated content and demonstrates MCP features, which is useful context. However, it lacks details on permissions, rate limits, error behavior, or whether it's read-only/mutative. The description doesn't contradict annotations (none exist), but leaves behavioral gaps for a tool with structured output.

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

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

The description is efficiently structured with a clear purpose statement, demonstration context, and separate Args/Returns sections. Every sentence adds value: the first explains what it does, the second provides context, and the third/fourth document parameters and returns. No wasted words, and key information is 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?

Given the tool has an output schema (so returns needn't be detailed in description) and only one parameter with good semantic coverage in the description, this is reasonably complete. The description explains the parameter's effect and the tool's role in demonstrating MCP features. However, for a tool with no annotations, it could better address behavioral aspects like idempotency or error cases.

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

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

Schema description coverage is 0%, but the description compensates well by explaining the single parameter's purpose: 'Whether to include optional fields in the response (default: False)'. This adds clear semantic meaning beyond the schema's type/boolean/default. Since there's only one parameter, the description effectively covers it, earning a high score despite low schema coverage.

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

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

The description clearly states the tool's purpose: 'Returns structured content that conforms to a well-defined JSON schema.' It specifies the verb ('returns') and resource ('structured content'), and distinguishes it from siblings by mentioning MCP's structured output capability. However, it doesn't explicitly differentiate from specific sibling tools like 'annotatedMessage' or 'echo' that might also return structured content.

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

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

The description provides no guidance on when to use this tool versus alternatives. It mentions demonstrating MCP's structured output, but doesn't specify scenarios, prerequisites, or exclusions compared to sibling tools like 'annotatedMessage' or 'echo'. The agent must infer usage from the generic purpose statement 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 of behavioral disclosure. It only states the basic function of adding numbers without addressing potential behavioral traits like error handling (e.g., for non-numeric inputs), performance characteristics, or any limitations (e.g., precision issues with floating-point numbers). This leaves significant gaps in understanding how the tool behaves beyond the core 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 highly concise and well-structured, with a clear purpose statement followed by separate sections for Args and Returns. Every sentence earns its place by providing essential information without redundancy, making it easy to scan and understand quickly.

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

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

Given the tool's low complexity (simple addition), 2 parameters with 0% schema coverage, and the presence of an output schema (implied by the Returns section), the description is mostly complete. It covers the purpose, parameters, and return value adequately. However, it lacks details on behavioral aspects like error cases or limitations, which could be relevant 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 description adds meaningful semantics beyond the input schema, which has 0% description coverage. It explicitly defines parameters 'a' and 'b' as 'the first number to add' and 'the second number to add', clarifying their roles. However, it doesn't elaborate on constraints like valid ranges or types beyond 'number', which the schema already covers with 'anyOf' for number/integer.

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

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

The description clearly states the specific action ('Add two numbers together') and identifies the resource (two numbers). It distinguishes from sibling tools like 'echo' or 'sampleLLM' by focusing exclusively on mathematical addition. The purpose is unambiguous and well-defined.

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

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

The description provides explicit guidance on when to use this tool ('when you need to sum or add two numbers'), which is clear and helpful. However, it doesn't specify when NOT to use it or mention alternatives among sibling tools, such as whether other tools might handle more complex mathematical operations or different data types.

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