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 authentication requirements, side effects (modifying the draft), file size limits, or that attachments are appended. The description gives minimal insight into 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 a single short sentence, which is concise but at the expense of completeness. It fails to convey essential information about parameters, return values, or prerequisites, making it under-specified rather than genuinely 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?

Given the tool has 5 parameters, no annotations, and an output schema (not described), the description is highly incomplete. It omits prerequisites, error handling, result structure, and any constraints, leaving the agent without sufficient context 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?

With 0% schema coverage, the description adds no parameter details beyond what the schema provides. While parameter names like 'message_id' and 'content_base64' are somewhat self-explanatory, the description misses clarifying ambiguous fields like 'name' (filename?) and does not explain defaults or constraints.

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 ('attach') and the resource ('file to draft message'), including that the file is base64-encoded. However, it does not differentiate from similar tools like 'manage_draft' or 'get_attachments', missing context about its specific role.

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

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

No guidance on when to use this tool versus alternatives, nor any prerequisites (e.g., draft existence) or exclusions. Sibling tools like 'create_draft' or 'manage_draft' might be more appropriate for other draft 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?

Without annotations, the description discloses behavior changes based on environment (Lambda wrapper vs local). It does not mention side effects, but no destructive behavior is implied. Adding notes on whether it makes network calls or requires auth would improve 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?

Two sentences, no redundant words. The key purpose and environment-specific behavior are front-loaded. Every sentence adds value, making it efficient and clear.

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 an output schema (not shown), the description explains the tool's purpose and special case. It is mostly complete for a zero-parameter tool, though a note that it requires no inputs would slightly enhance completeness.

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

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

With no parameters, the schema coverage is 100%. The description adds context about what the tool shows (auth config and cached accounts), which adds value beyond the empty schema. Baseline for 0 parameters is 4, and the description meets it.

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

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

The description clearly states the tool shows auth configuration and cached accounts, using the verb 'Show'. It specifically distinguishes behavior in the MCP Lambda wrapper, differentiating it from sibling tools like start_auth and finish_auth.

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 does not explicitly state when to use this tool versus siblings like start_auth or finish_auth. It implies usage for checking status but lacks explicit guidance on alternatives or prerequisites.

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

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

With no annotations, the description carries full burden and excels. It details scanning order (newest-first), exact limit handling, client-side filtering, response fields (truncated, stop_reason, already_gone), and the separation of collection and action phases. No contradictions.

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

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

The description is well-structured with a clear opening, detailed parameter behavior, and response interpretation. It is concise and informative, though a slightly more compact explanation of default behavior could earn a 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?

The description covers the main behavior and key responses (truncated, already_gone) but omits explanations for many parameters. The presence of an output schema mitigates missing return value details, but parameter semantics remain incomplete for a tool with 10 optional parameters.

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

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

Schema description coverage is 0%, so the description must explain parameters. It only provides detailed semantics for 'limit'; other parameters like 'action', 'folder', 'destination', and filter criteria are named but not described. An agent would need to infer their meaning from context.

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 'Bulk-manage messages with filtering' and lists supported actions (dry-run, delete, move, mark-read). This clearly identifies the tool's purpose and distinguishes it from single-message tools like delete_message or move_message.

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

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

The description explains default behavior (full folder scan) and the exact semantics of the limit parameter, but does not explicitly state when to prefer this tool over alternatives like looping over individual actions. The context of sibling tools makes the use case clear, but explicit guidance would improve the score.

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

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

No annotations are provided, so the description must disclose behavioral traits. It does not mention that the tool is read-only, or any required permissions, rate limits, or side effects. The vague term 'Check' implies non-destructive operation but 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 concise, using two sentences to convey the core functionality and two modes. No unnecessary information is present, and it is front-loaded with the purpose.

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

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

Given the complexity (6 parameters, 3 required) and absence of parameter descriptions, the description is incomplete. It does not explain required fields, default values, or usage constraints. The output schema exists but the description does not leverage that to compensate for lack of input guidance.

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

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

With 0% schema description coverage, the description should add meaning to parameters. It only explains the 'mode' parameter values, leaving the other five parameters (emails, start_iso, end_iso, account_id, duration_minutes) undescribed. This is insufficient for an agent to understand correct usage.

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: checking calendar availability, with two explicit modes 'free_busy' and 'suggest'. It distinguishes this tool from sibling tools like 'get_event' and 'list_events' by focusing on availability rather than event details.

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

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

The description does not explicitly state when to use this tool versus alternatives, nor does it provide guidance on when to use each mode. However, the distinct purpose implies usage context, so it is adequate but lacks explicit direction.

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

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

No annotations provided, so description must fully disclose behavior. It states the draft is saved to Drafts but does not mention authentication, rate limits, whether drafts are overwritten, or return value details.

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

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

Three sentences front-loaded with purpose and usage. Very concise, though could include a brief note about return value or required permissions.

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 having an output schema, the description omits parameter explanations and important behavioral details. With 7 parameters and 0% schema coverage, more information is needed for agent to use 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 coverage is 0%, yet description adds no meaning to any parameter. It mentions attachments but the schema has no attachment field; does not explain send_as, account_id, or cc/bcc.

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

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

The description clearly states it creates a draft email saved to Drafts, and distinguishes from sending by directing to use manage_draft. Among sibling tools like send_message and manage_draft, the purpose is explicit and unique.

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

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

Explicitly says when to use (need attachments or multi-step) and points to manage_draft for sending, providing clear context and an alternative.

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 does not mention side effects, permissions, rate limits, or how the tool handles conflicts or missing fields, leaving significant gaps for a creation tool.

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

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

The description is extremely concise with two clear sentences. The most important action is front-loaded, and there is no superfluous 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?

Despite having an output schema (so return values needn't be explained), the description fails to provide adequate context for a tool with 10 parameters and no annotations. It only addresses user_id, leaving many behavioral and parameter details unaddressed.

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

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

Schema description coverage is 0%, and the description only adds meaning for user_id (shared calendars). Other key parameters like subject, start_iso, end_iso, body, and attendees are not explained beyond their names, providing minimal added value.

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

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

The description clearly states the action ('Create a new calendar event') and specifies the resource. It distinguishes from siblings by mentioning 'Pass user_id for shared calendars', which differentiates it from other event-related 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 some context for when to use the user_id parameter (shared calendars), but does not offer explicit when-to-use or when-not-to-use guidance relative to other tools like update_event or list_events.

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

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

No annotations are provided, so the description bears full burden. It merely states 'create' without disclosing permissions, side effects (e.g., uniqueness constraints), or confirmation of success. Minimal 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 concise sentence with no wasted words. However, it lacks visual structure (e.g., bullet points) that could improve scannability.

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

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

Given three parameters, no annotations, and an output schema, the description is too brief. It does not mention what the tool returns (e.g., folder ID) or error conditions, leaving gaps for an agent's invocation decisions.

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

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

Schema coverage is 0% (no parameter descriptions). The description mentions 'name' implicitly and 'parent_folder_id' as optional, but does not explain 'account_id'. It adds partial meaning but insufficiently compensates for the lack of schema descriptions.

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

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

The description clearly states the action 'create' and resource 'mail folder', and specifies optional parent folder creation. It effectively distinguishes from sibling tools like list_folders which list rather than create.

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 creating mail folders but provides no explicit guidance on when to use this tool versus alternatives, nor any conditions or prerequisites.

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

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

No annotations are provided, placing the full burden on the description. It indicates the tool is destructive ('Delete or cancel') but fails to disclose consequences such as irreversibility, notification effects, or permission requirements. The description lacks sufficient behavioral disclosure for a mutation tool.

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 at two sentences, with no redundant information. The first sentence clearly states the purpose, and the second adds a useful hint. However, the brevity comes at the cost of omitting important details 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?

Given the lack of annotations and 0% parameter descriptions, the description is incomplete. It does not cover return values (despite a known output schema), error scenarios, or behavioral nuances like the difference between delete and cancel. For a destructive tool, more context 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?

With 0% schema description coverage, the description should compensate but only adds meaning for one parameter ('Pass user_id for shared calendars'). The other parameters (event_id, account_id, cancel_message) are left unexplained, leaving significant gaps in understanding their role and usage.

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: 'Delete or cancel a calendar event.' It uniquely identifies the action and resource, distinguishing it from siblings like create_event, update_event, and respond_to_event. The additional hint about user_id for shared calendars adds specificity.

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 by stating the action, but provides no explicit guidance on when to use this tool versus alternatives (e.g., update_event) or when not to use it. The mention of 'Pass user_id for shared calendars' offers context but does not serve as a full usage guideline.

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

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

The description mentions that the tool can either delete permanently or move to Deleted Items, which is key behavioral information. It also notes the required Mail.ReadWrite permission. However, it does not explain the role of the 'permanent' parameter or consequences of actions, leaving gaps for an agent.

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

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

The description is a single sentence with no wasted words. However, it lacks structure (e.g., bullet points) that would improve readability for multiple behaviors.

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 having an output schema, the description does not cover return values, error conditions, or the exact effect of parameters. The tool's dual behavior (delete vs. trash) is mentioned but not fully elaborated, making it incomplete for safe 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?

With 0% schema description coverage, the description must explain parameters. It fails to do so: no details on 'message_id', 'permanent', or 'account_id'. The agent cannot understand parameter behavior from the description alone.

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 a message or move it to Deleted Items. It specifies the required permission, which adds context. However, it does not explicitly differentiate from sibling tools like move_message, which may also handle moving messages.

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 move_message or update_message. The description lacks context for choosing this tool over other message 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 must disclose all behavioral traits. It explains that the tool completes the device-code flow after user approval and notes mode-specific behavior. However, it does not mention potential side effects (e.g., if called when auth is already complete), rate limits, or what happens on failure. This leaves 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 extremely concise with two sentences. The first sentence states the primary purpose, and the second adds context about modes. Every word is necessary; no fluff.

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

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

Given zero parameters and an output schema (presumed to document return values), the description is largely complete. It covers both Lambda and local modes. However, it could explicitly mention that output is provided (e.g., tokens or errors) to fully contextualize the tool's role.

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, so per guidelines the baseline is 4. The schema coverage is 100% (empty schema is fully covered). The description adds no parameter information because none is needed, which 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 purpose: complete Microsoft authentication after user approval. It distinguishes from sibling auth_status by specifying that finish_auth is not needed in Lambda mode, where auth_status should be called instead. This makes the purpose unambiguous and differentiated.

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

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

The description explicitly tells when to use this tool versus alternatives: in Lambda mode, use auth_status; in local mode, use this tool to complete the device-code flow. This provides clear context and excludes improper 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?

The description discloses the critical behavioral trait: it defaults to dry-run (preview only) and requires dry_run=False to send. No annotations are provided, so the description carries full burden; it adequately covers the main behavioral nuance, though it could mention side effects (e.g., creating a sent copy).

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

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

The description is two sentences long, with no wasted words. It front-loads the core action ('Forward a message') and immediately addresses the key behavioral twist (dry-run default). Every sentence earns its place.

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

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

Despite having an output schema, the tool has 6 parameters (2 required) and moderate complexity. The description does not mention required parameters, the recipient list format, or optional body customization. A more complete description would list key parameters or provide a quick example.

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 explains only the 'dry_run' parameter explicitly. For 6 parameters with 0% schema description coverage, the description fails to add meaning for 'to', 'body', 'send_as', 'account_id', and 'message_id'. Parameter meanings are left to inference from names, which is insufficient.

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

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

The description clearly states the verb 'forward' and the resource 'message', and distinguishes from siblings like 'send_message' and 'reply_to_message' by mentioning the dry-run behavior. It is specific and leaves no ambiguity about what the tool does.

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

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

The description implies usage context: forwarding a message with an optional dry-run preview. It does not explicitly state when not to use or list alternatives, but the name and brief instructions ('Set dry_run=False to actually send') provide sufficient guidance for most agents.

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 discloses two distinct behaviors (list vs. download) and notes the base64 encoding threshold (under 1.5 MB). However, it does not clarify what happens for attachments over 1.5 MB or other potential error conditions, leaving minor gaps.

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

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

The description is extremely concise: two sentences that front-load the purpose and then provide necessary conditional details. Every word adds value 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 that an output schema exists (so return details are not needed), and the tool's behavior is relatively simple, the description covers the essential modes. However, it could briefly mention authentication prerequisites or handling of multiple attachments for 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 0%, so the description must compensate. It explains the role of message_id (implied) and attachment_id (controls behavior), but does not mention account_id at all, which is an optional parameter. Thus, it adds meaning for two of three parameters.

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

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

The description clearly states the tool's purpose: getting attachments for a message. It further distinguishes the two modes based on whether an attachment_id is provided, making the behavior explicit and differentiating it from sibling tools like add_attachment_to_draft.

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 implicit guidance on when to list metadata versus download an attachment, but it does not explicitly compare usage with alternatives (e.g., list_messages, add_attachment_to_draft) or mention when not to use this tool.

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

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

No annotations are provided, and the description does not disclose what 'full details' includes, error handling, permissions, or any side effects. The output schema may describe the return, but the description adds minimal 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?

Two concise sentences front-load the main purpose and a specific usage note; no unnecessary words.

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

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

The description lacks context about required parameters (event_id), optional parameter account_id, typical usage scenarios, and differentiation from 25+ sibling tools. The output schema exists but is not mentioned.

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 only explains the user_id parameter (for shared calendars), leaving event_id and account_id unexplained.

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 full details for a specific calendar event, which is distinct from sibling tools like list_events (list), create_event (create), or update_event (update).

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?

It provides a usage hint for the user_id parameter ('Pass user_id for shared calendars') but does not explain when to use this tool over alternatives like list_events or check_availability.

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

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

The term 'read-only' implies non-destructive behavior, but with no annotations provided, the description lacks detail on permissions, whether the message is marked as read, or what the response includes.

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?

A single, front-loaded sentence with no filler words. Very concise, though it could expand slightly on usage or parameters without becoming 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?

For a simple get tool, the description is minimally adequate with output schema present. However, given many sibling tools and no usage guidance, it is not 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?

Schema description coverage is 0%, yet the description does not explain the meaning or formatting of account_id or message_id beyond what the schema still provides (attribute names).

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 'a specific mail message', and explicitly calls it 'read-only', which distinguishes it from mutation tools like update_message or delete_message.

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_messages or list_messages. The description does not mention exclusions or prerequisites.

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

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

No annotations are provided, so the description must fully disclose behavioral traits. It only states the tool lists aliases but omits details like pagination, filtering, or whether it returns all aliases. The minimal description fails to compensate for missing annotations.

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

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

The description is a single, clear sentence that efficiently conveys the core purpose. While very brief, it is not verbose and avoids 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?

Although an output schema exists, the description provides no context about return values or behavior such as ordering, error cases, or filtering. For a list operation, more detail is needed to be 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?

The input schema has one optional parameter (account_id) with 0% description coverage, and the tool description does not mention the parameter at all. No additional meaning is provided 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 'list', resource 'email aliases', and context 'for the authenticated user', making the purpose unambiguous. It distinguishes this tool from siblings like list_folders and list_messages.

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 search_messages or list_folders. It lacks any 'when to' or 'when not to' 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?

Without annotations, the description must disclose behavior but only says 'List readable calendars'. It does not mention whether it returns all calendars, pagination, authentication requirements, or any side effects. The read-only nature is implied but 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?

Two sentences with clear front-loading of purpose and no unnecessary words. Every sentence adds value.

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

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

Given the presence of an output schema that likely describes return values, the description provides the essential purpose and a key usage hint. However, for a list tool in a complex domain, more context like scope of calendars returned (own vs. shared) 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?

The description adds meaning for user_id by explaining its use for shared calendars with an example, but account_id is left unexplained. Schema description coverage is 0%, so this partial help is welcome but insufficient for full 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?

Description clearly states verb 'List' and resource 'readable calendars', distinguishing from sibling tools like list_events or get_event which operate on events, not calendars.

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

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

Provides guidance to pass user_id for shared calendars, which is helpful for usage, but does not specify when not to use this tool or compare with alternatives like list_events for calendar-related queries.

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 behaviors. It does not mention pagination, rate limits, authentication needs, or what happens with empty results. For a listing tool, this is insufficient.

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

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

The description is very concise (two sentences), but it omits critical details. Conciseness is maintained, but at the cost of completeness. A slightly longer description with parameter context would improve this.

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 6 parameters, no annotations, and 0% schema coverage, the description is incomplete. It lacks information on defaults (e.g., limit default 25), required vs optional parameters, and behavior without filters. The presence of output schema slightly reduces the burden, but not enough.

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 only adds meaning for user_id (shared calendars hint). Other parameters like start_iso, end_iso, limit, account_id, calendar_id are left unexplained, forcing the agent to infer from names.

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

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

The description clearly states the action ('List events') and context ('from a calendar in a time range'), distinguishing it from sibling tools like get_event (single event) and create_event (different action). It lacks explicit differentiation but is specific enough.

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 only guidance is 'Pass user_id for shared calendars,' which is a minor hint. There is no mention of when to use this tool vs alternatives like get_event or search_people, nor any exclusion 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?

No annotations provided, so description carries burden. It adds subfolder navigation context but omits disclosure of authentication requirements, effects of account_id and include_hidden parameters, and output structure beyond mentioning child_folder_count.

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

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

Two sentences, no wasted words. Front-loaded with core purpose, immediately followed by actionable guidance.

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

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

Given no annotations and missing parameter descriptions for account_id and include_hidden, the description is incomplete. It also does not mention authentication context or error handling, despite having an output schema.

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 description only explains parent_folder_id usage. account_id and include_hidden are not described at all, leaving two of three parameters unexplained.

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 'List mail folders,' which is a specific verb+resource. It distinguishes from sibling tools like list_messages and list_calendars. The mention of subfolder listing further clarifies 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?

Clear guidance: use parent_folder_id to list subfolders and check child_folder_count. However, it does not explicitly exclude when not to use this tool or mention alternatives beyond implied sibling names.

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

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

Given no annotations, the description fully discloses key behaviors: server-side filtering, field selection with `id` always included, and inclusion of `conversation_id`. It accurately portrays a read-only operation without contradictions.

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

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

The description is three sentences, each earning its place. First sentence states core purpose, second and third detail parameter usage and output benefit. No redundant 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 presence of an output schema (not shown), the description covers necessary context: listing from a folder, ordering, filtering, field selection, and threading info. It is adequate for a simple listing 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?

With 0% schema description coverage, the description adds value by explaining `since` (ISO-8601 format) and `fields` (override columns, id always included). Other parameters (`limit`, `folder`, `account_id`) are not addressed but their defaults are 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 clearly states 'List recent mail messages from a folder, newest first.' It specifies the verb, resource, and ordering, differentiating it from sibling tools like `search_messages` or `get_message`.

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

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

Provides explicit guidance for the `since` and `fields` parameters, and hints at use cases for threading via `conversation_id`. However, it does not directly compare to alternatives like `search_messages` for complex filtering.

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

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

With no annotations, the description carries full burden. It discloses the core behavior (update and optionally send) but lacks details on side effects (e.g., what happens after sending, multiple updates, permissions). Some transparency is provided but not complete.

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

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

Two sentences with clear structure: first sentence states purpose, second gives usage hint. Every word adds value; no redundancy.

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

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

Despite having an output schema, the description does not mention return values. With 9 parameters and no annotations, it lacks explanations for error cases, parameter details, and post-conditions, making it incomplete for a complex tool.

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

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

Schema description coverage is 0%. The description only mentions 'Provide fields to update' and the send parameter, ignoring explanation of other 7 parameters (cc, to, bcc, body, subject, etc.). It does not compensate for the lack of schema descriptions.

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

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

The description clearly states 'Update and/or send a previously created draft,' using a specific verb and resource. It distinguishes from siblings like create_draft by mentioning 'previously created,' and implies this is for existing drafts.

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

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

Provides explicit usage sequence: 'Use after create_draft and optionally add_attachment_to_draft.' Also explains the send parameter's role. However, it does not specify when not to use it or mention alternative tools like send_message.

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

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

The description discloses the basic operation and permission requirement. However, it does not mention side effects, rate limits, or what the output schema contains. With no annotations, more detail would be beneficial.

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 but lacks necessary detail about parameters and usage, making it under-specified rather than efficiently 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?

Despite the presence of an output schema, the description fails to cover parameter semantics and usage context. The tool has three parameters and requires clear explanations 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 0%. The description does not explain any of the three parameters, leaving the agent without guidance on what values to provide for message_id, destination, or account_id.

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 ('Move a message to another folder'), specifying the verb and resource. It is distinct from most siblings but does not explicitly differentiate from other message manipulation tools like bulk_manage_messages.

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 vs. alternatives. The only extra information is the required permission, which does not help an agent choose between move_message and similar 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 discloses the dry-run default and how to actually send, but does not mention other behavioral traits such as required permissions, irreversibility, or side effects. Partial but not 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 two sentences, front-loaded with the core purpose, and contains no filler. Every word is functional.

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 having 6 parameters (2 required) and an output schema, the description is very brief. It lacks parameter explanations, usage scenarios, and comparison to siblings. For a tool of this complexity, more 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 description coverage is 0%, meaning the schema provides no parameter descriptions. The description only adds context for dry_run, while other parameters (body, send_as, reply_all, account_id, message_id) are left unexplained. Insufficient value 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 states the verb 'Reply' and the resource 'message', differentiating it from siblings like send_message and forward_message. It also notes the dry-run default, which is specific to this tool.

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 context: it mentions dry-run behavior but does not specify when to use this tool versus alternatives like send_message or forward_message, nor does it give 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?

No annotations provided, so description must disclose behavioral traits. It mentions mutation (respond) but doesn't describe side effects (e.g., notifications to organizer), permissions needed, or what response values are accepted. The output schema exists but the description adds no 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?

Very short (two sentences), which is concise, but at the expense of necessary detail. It is front-loaded with the primary purpose, but lacks substance on 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?

With 5 parameters (2 required), no annotations, but an output schema exists, the description is significantly incomplete. It fails to explain the purpose of multiple parameters, response format, and behavioral implications, leaving critical 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 coverage is 0%, but the description only clarifies user_id ('for shared calendars'). It does not explain the required event_id and response, nor optional message and account_id. The meaning and constraints of the response parameter (e.g., accepted/declined) are missing.

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 ('Respond to a meeting invite') and the resource (meeting invite). It distinguishes from sibling tools like create_event or update_event, which handle different operations. However, it could be more specific about the response types (e.g., accept, decline).

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?

Minimal guidance: only mentions passing user_id for shared calendars. No explicit when-to-use vs alternatives (e.g., update_event might also modify event status), no prerequisites, and no when-not-to-use advice.

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 does not mention pagination, rate limits, authentication, search syntax, or output format, leaving the agent with minimal information 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 a single short sentence, which is concise but under-specified. It lacks any structure or details that would help the agent, though it avoids fluff.

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

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

Given no annotations, three parameters, and many sibling tools, the description is severely incomplete. It fails to provide sufficient information for an agent to correctly select and invoke 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?

Schema description coverage is 0%, and the description provides no explanation for parameters (query, limit, account_id). The meaning of 'query' and the purpose of 'account_id' are entirely unspecified, forcing the agent to infer from the schema alone.

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 'Search messages using Microsoft Graph message search', which is clear about the verb and resource but lacks specificity about search capabilities and does not differentiate from sibling tools like list_messages or search_people.

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, context, or exclusions.

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

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

No annotations are provided, so the description must carry the burden. It mentions no side effects, authorization, rate limits, pagination behavior, or error handling. The search is likely safe and idempotent, but not explicitly disclosed.

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, making it concise, but it omits important details. It is front-loaded with action and resource, but arguably too terse for full usability.

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 an output schema but no parameter descriptions, and given the tool's complexity (3 params, search functionality), the description is incomplete. It fails to explain result format, search scope, or ordering, making it insufficient for confident agent use.

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

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

Schema description coverage is 0%, so the description should clarify parameter meaning. It hints that 'query' is a name, but gives no examples, no details on 'limit' or 'account_id', nor whether the search is exact or fuzzy.

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 ('Search for people by name') and the outcome ('find their email addresses'), identifying the resource and purpose. It distinguishes the tool from siblings like 'search_messages' as it is the only people search tool.

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 when needing to find email addresses of people by name, but provides no explicit when-to-use or when-not-to-use guidance, nor compares to alternatives. The context is clear but minimal.

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 dry_run defaults to true (preview only) and must be set to false to send. It also notes the no-attachments constraint. While it does not detail all edge cases or output, the major behavioral traits are effectively communicated.

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

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

Three concise sentences. First sentence states purpose and constraint, second explains dry-run behavior, third provides alternative for attachments. Every sentence 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 8 parameters (3 required), no annotations, but an output schema exists (though not shown), the description covers core behavior, constraints, and an alternative workflow. It does not explain output or errors, but the output schema mitigates that. For a standard send tool, it is sufficiently 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 0%, so the description must compensate. It adds meaning for the dry_run parameter (default true, must set false to send) and implies the role of to, subject, body. However, it does not describe cc, bcc, send_as, account_id, leaving those parameters with only their names for context. Partial but incomplete compensation.

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 'compose and send', the resource 'email', and a key constraint 'no attachments'. It also distinguishes from sibling tools by directing users to an alternative pipeline for attachments.

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 when-to-use (sending plain emails) and when-not-to-use (attachments), along with a specific alternative (create_draft + add_attachment_to_draft + manage_draft). It also explains the dry-run behavior and how to actually send.

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?

Without annotations, the description carries full burden; it discloses mode-dependent behavior and outputs (URL vs device-code flow), though does not mention side effects or security considerations, which are minimal for this tool.

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

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

The description is two sentences, front-loaded with purpose, and contains 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 no parameters and a known output schema, the description adequately explains the two possible outcomes (OAuth URL or device-code flow), making it 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?

There are no parameters, so schema coverage is 100%. The description adds value by explaining the mode-dependent behavior without needing to elaborate on 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 it starts Microsoft authentication and differentiates two modes (Lambda vs local), making the tool's purpose specific 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?

The description explains when each mode applies (Lambda vs local), but does not explicitly contrast with sibling tools like 'auth_status' or 'finish_auth', though context implies it is the first step.

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

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

No annotations provided, so description must disclose behavioral traits. It confirms mutation ('update') but omits details like required authentication, destructive potential, or whether fields are overwritten or merged.

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

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

Two sentences, front-loaded with purpose and a helpful hint. Efficient but could accommodate more context without becoming 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?

With 10 parameters, no annotations, and an output schema present, the description falls short. It lacks parameter semantics, behavioral details, and coverage of edge cases, leaving significant gaps for the agent.

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

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

Schema description coverage is 0%, but the description only mentions 'user_id' without explaining any other parameter (e.g., start_iso, attendees). Fails to add meaning beyond the schema.

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

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

Description clearly states the verb ('update') and resource ('existing calendar event'), distinguishing it from sibling tools like 'create_event' and 'delete_event'. However, it does not explicitly contrast with other tools that might modify events.

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?

Minimal guidance: mentions 'Pass user_id for shared calendars' but no explicit when-to-use or when-not-to-use context compared to related tools like 'respond_to_event' or 'check_availability'.

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 description must disclose behavioral traits. It only mentions 'update' without discussing mutation implications, permissions, side effects, or whether changes are incremental. Minimal 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?

Single sentence, front-loaded with verb and resource, lists key parameters without redundancy. Every word is necessary and informative.

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 5 parameters, no schema descriptions, no annotations, and an output schema, the description is incomplete. It should explain all parameters, mention response behavior, and clarify incremental updates. Missing account_id is a notable gap.

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

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

Schema coverage is 0%, so description must explain parameters. It adds meaning for is_read, flag_status, and categories, but omits account_id and does not clarify message_id beyond its required status. Partially compensates for missing 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?

Description clearly states the tool updates message properties, listing specific attributes: read/unread, follow-up flag, and color categories. This distinguishes it from siblings like get_message, delete_message, or move_message.

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

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

No guidance on when to use this tool versus alternatives like bulk_manage_messages. Does not specify prerequisites or situations where other tools are preferred.

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