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

No annotations provided; description only mentions cancellation and notification but omits critical behavioral details like permission requirements or side effects on related resources.

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?

Concise single-line purpose followed by structured Args/Returns; every sentence is informative 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?

Covers key aspects given the tool's simplicity and the presence of an output schema, but could include context such as organizer requirements or cancellation limitations for full 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?

Description explains the purpose of each parameter (item_id as meeting identifier, message as optional cancellation note), adding value beyond the schema which only provides types and defaults.

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?

Clearly states the tool cancels/deletes a calendar meeting and notifies attendees, distinguishing it from sibling tools like update_meeting or respond_to_meeting.

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?

Implied usage is clear (use when you want to cancel a meeting), but lacks explicit guidance on prerequisites or when to avoid using it (e.g., not for accepting invitations).

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 internal action (GetFolder call) and return fields (authenticated bool, mailbox name, cookie path). No side effects are disclosed, but as a read-only check, it is transparent.

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

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

Three sentences efficiently convey purpose, method, and return. Front-loaded with the main purpose. 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 zero parameters and an output schema, the description adequately covers the tool's behavior and return values. It is complete for a simple status check 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?

There are no parameters, so schema coverage is 100%. The description does not need to add parameter details, meeting the baseline for 0-param tools.

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

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

The description clearly states the tool checks if the OWA session is authenticated, uses a specific verb ('check') and resource ('session authentication'). It distinguishes from siblings like 'login' by focusing on status verification.

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

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

The description implies use for lightweight session status checking by mentioning 'lightweight GetFolder call'. It does not explicitly state when to use vs alternatives, but the context makes the use case clear.

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; description only states it creates a folder and returns id/name. Does not disclose side effects, error conditions (e.g., duplicate folder), permissions required, or whether it is idempotent. A creation tool should disclose more behavioral traits.

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 concise and well-structured with Args and Returns sections. Every sentence adds value; no unnecessary 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?

Covers input parameters and return value adequately for a simple creation tool. However, missing behavioral context (e.g., error handling, permissions) reduces completeness. The output schema existence likely covers return structure, but description includes it anyway.

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?

Despite 0% schema description coverage, the description fully explains both parameters: name is display name, parent_folder_id explains default, and acceptable values (distinguished name or raw ID). Adds significant meaning beyond the schema types.

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?

Clearly states 'Create a new mail folder' with specific verb and resource. Distinguishes from sibling folder tools like delete_folder, rename_folder.

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 what the tool does but provides no guidance on when to use it versus alternatives, or any prerequisites. Usage context is implied.

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

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

No annotations provided, so the description carries full burden. It minimally states creation and return of item_id, but omits crucial behaviors like automatic invitation sending, permission requirements, or side effects on attendee calendars.

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 with a clear 'Args' and 'Returns' structure. Every sentence adds value, 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 the high parameter count (12) and no annotations, the description could cover more behavioral context such as default behavior for all-day events or attendee handling. The presence of an output schema reduces the need to describe return values, but overall completeness is adequate but not thorough.

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 compensates by providing brief explanations for each parameter, including format hints (e.g., date in YYYY-MM-DD) and allowed values for importance and sensitivity. However, some descriptions are tautological (e.g., 'subject: Meeting subject/topic').

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 'Create a new calendar meeting,' which is a specific verb-resource pair. It distinguishes itself from sibling tools like cancel_meeting and update_meeting by focusing on creation.

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. No mention of prerequisites, typical use cases, or exclusions. The description is silent on 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?

Description discloses the behavior of the permanent parameter (hard delete vs move to deleted items). However, no annotations exist, and the description does not cover other behavioral traits such as authentication requirements, error handling, or idempotency.

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: a one-line purpose followed by a short Args section. Every sentence 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 the simplicity of the tool (delete with two params) and presence of an output schema, the description covers the core behavior adequately. It explains the permanent flag. Lacks details on error handling or edge cases but is acceptable.

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 compensates by explaining item_ids as 'List of Exchange ItemIds' and permanent. Adds meaning beyond the schema. Could include more detail on valid ItemIds.

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 'Delete one or more emails' clearly states the action and resource, distinguishing it from siblings like move_email and empty_folder.

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?

Describes behavior of the permanent parameter but does not provide explicit guidance on when to use this tool vs alternatives like move_email or empty_folder. Context is implied but not stated.

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

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

The description explains the difference between hard delete and soft delete via the permanent parameter, and mentions the return format. However, it omits details like permission requirements, behavior when the folder has contents, or error cases.

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 three sentences: a purpose sentence, parameter details, and return info. It is front-loaded and every sentence is 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?

For a simple tool with two parameters and an output schema, the description covers the essential aspects. It explains both deletion modes and return format. Minor missing details like error handling or permission notes do not significantly detract.

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 beyond the schema: folder_id is explained as from get_folders, and permanent is described with behavior and default. This compensates for the 0% schema description 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 'Delete a mail folder' with a specific verb and resource. It distinguishes from sibling tools like empty_folder, move_folder, and rename_folder by focusing on deletion.

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

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

No explicit guidance on when to use this tool versus alternatives like empty_folder. The purpose is clear, but there is no mention of prerequisites or when not to use it.

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

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

No annotations are provided, so the description carries full burden. It states the action but fails to disclose side effects (e.g., file overwrites), error behavior, or resource implications. The existence of an output schema is not mentioned, leaving agents uninformed about return values.

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 minimal and front-loaded, with one clear sentence followed by a concise args list. No redundant information is present.

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 only 2 parameters and an output schema, the description covers parameter meanings but omits any mention of output, error scenarios, or prerequisites like authentication. It is adequate but not thorough for a download 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?

Despite 0% schema description coverage, the description adds meaningful semantics: item_id is 'The Exchange ItemId of the email' and target_folder is 'Local directory to save files (default /tmp/attachments)'. This compensates for the schema gap.

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 'Download all file attachments from an email to disk,' specifying the verb, resource (attachments from an email), and destination. It distinguishes itself from sibling 'download_event_attachments' by targeting email 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 implies usage (downloading email attachments) but lacks explicit guidance on when to use vs. alternatives like 'download_event_attachments' or prerequisites (e.g., having the item_id, needing to log in). No exclusions are given.

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

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

No annotations provided; description only states the action but omits details like behavior when no attachments exist, overwrite policy, or need for authentication. Minimal behavioral disclosure.

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?

Description is extremely concise with one main sentence and a compact parameter list. No unnecessary words, front-loaded with 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?

Has output schema, so return values not needed, but description lacks context on prerequisites (e.g., login required), error handling, or behavior when no attachments. Adequate for a simple tool but incomplete for robust 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%, but the description's Args section explains both parameters (item_id as Exchange ItemId, target_folder with default). This adds meaning beyond the empty schema descriptions, though lacks details like how to obtain item_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 tool downloads all file attachments from a calendar event to disk, using specific verb and resource. It distinguishes from sibling 'download_attachments' by specifying event context.

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

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

No guidance on when to use this tool versus alternatives like 'download_attachments' or prerequisites. The agent is left to infer usage from 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?

Covers delete_sub_folders and permanent deletion options, but omits important behaviors like permissions required, error handling, or what happens with the folder itself when delete_sub_folders is true. No annotations provided to supplement.

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?

Concise with clear Args/Returns structure. Each sentence adds value, though 'Args:' section could be integrated more smoothly.

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?

Covers basic intent and parameters, but lacks behavioral details like permission requirements and edge cases. Output schema exists, so return value description is sufficient but minimal.

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 fully explains all three parameters including folder_id source and default behaviors for delete_sub_folders and permanent. With 0% schema coverage, this description compensates completely.

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?

Clearly states emptying all items from a mail folder. Identifies the action and resource, but does not explicitly distinguish from sibling delete_folder which removes the folder itself.

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 delete_folder. Does not mention prerequisites beyond folder_id, nor when not to use it.

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

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

With no annotations, the description bears full responsibility for disclosing behavior. It specifies that the tool only examines the user's own calendar and only returns slots within working hours (default 9-18). It does not mention potential limitations like ignoring holidays or overlapping events, but it provides adequate transparency for typical use.

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 one-line summary followed by clearly formatted Args and Returns sections. Every sentence is informative, no wasted text, and the most important information (purpose) 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 5 parameters, no annotations, and an output schema, the description is nearly complete. It covers all parameters, default behaviors, and return format. It could mention timezone handling or what happens when no free time exists, but overall it is sufficient for correct tool selection and invocation.

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

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

The schema has 0% description coverage, so the description adds complete parameter semantics. It explains each parameter (start_date in YYYY-MM-DD, end_date defaults to start_date, duration_minutes default 30, start_hour default 9, end_hour default 18), which adds significant meaning beyond the schema's titles.

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 finds free time slots in the user's own calendar, which is a specific verb-resource combination. It distinguishes itself from siblings like 'find_meeting_time' by focusing on the user's personal calendar rather than group scheduling.

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 it is for analyzing one's own calendar to find available slots within working hours, but it does not explicitly state when to use this tool versus alternatives (e.g., 'find_meeting_time' for group availability). The context is clear but no exclusions or alternative guidance 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?

No annotations provided, but the description discloses the API used, default parameters, and the format of results. It implies a read-only operation with no destructive effects, which is sufficient for this search 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 well-structured with an Args section, and each sentence adds value. It is appropriately sized given the parameter count, though slightly verbose in listing defaults.

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?

Has an output schema, so return values are documented. Description explains both input and output structure, including free_slots keyed by date with start/end/duration. Completely covers the tool's behavior.

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

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

Schema description coverage is 0%, but the description adds meaning to all parameters: explains comma-separated emails, date format, defaults for end_date, duration_minutes, start_hour, end_hour. This 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?

The description clearly states the tool finds meeting times that work for multiple people, using a specific API (OWA GetUserAvailability). It distinguishes from siblings like find_free_time (likely single person) and create_meeting (creation vs finding).

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 that it checks cross-mailbox availability and searches each weekday, with defaults provided. It does not explicitly state when not to use or mention alternatives, but the context is clear for scheduling group meetings.

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 adds behavioral context by naming the underlying API (ResolveNames) and directory (Active Directory), implying it is a read-only search. It also describes the return fields, giving the agent a good understanding of 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 concise and well-structured. It starts with a clear purpose sentence, then elaborates on usage, parameters, and return values in a logical order. No unnecessary sentences or repetition.

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

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

Given the low complexity (one required parameter, no enums, no nested objects) and the presence of an output schema, the description covers all necessary aspects: purpose, parameter semantics, return format, and underlying technology. It is complete for an agent to use the tool effectively.

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

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

The input schema has 0% description coverage, so the description must compensate. It clearly explains the single parameter 'query' as 'Name, email address, or keyword to search for,' adding significant meaning beyond the schema's type definition.

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: 'Search for people in the corporate directory.' It specifies the resource (people), the verb (search), and the method (Exchange ResolveNames API against Active Directory). This distinguishes it from sibling tools which focus on emails, meetings, and folders.

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 the tool (searching for employees by name, email, or keyword). It does not explicitly state when not to use it or mention alternatives, but the context is sufficient and no exclusion is needed given the sibling tools are distinct.

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 does some work by explaining that the body is placed above the forwarded content. However, it omits important details like whether the email is sent immediately, marked as read, or if drafts are created.

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, using a single introductory sentence followed by a clear bullet list for parameters. 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 existence of an output schema, the description need not explain return values. However, it lacks behavioral context such as side effects or authentication requirements, making it only partially 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 description adds significant value beyond the schema by specifying that item_id is an Exchange ItemId, to is a comma-separated list, and body is an optional message placed above the forwarded content. This compensates for the 0% schema description coverage.

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

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

The description clearly states the verb 'forward' and resource 'email', distinguishing it from siblings like reply_email and send_email. However, it does not elaborate on the exact forwarding mechanism (e.g., inline vs attachment).

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 reply_email or send_email. The description does not mention prerequisites or context for forwarding.

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 clearly documents that include_body is ignored when expand_recurring=True, and that expand_recurring returns fewer fields per event. This informs the agent of key trade-offs and behavioral nuances beyond a simple read operation.

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

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

The description is well-structured with Args and Returns sections, making it easy to parse. It is slightly verbose, particularly in the include_body and expand_recurring explanations, but every sentence adds value. The key information is front-loaded in the first sentence.

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 output schema exists, so the description does not need to fully detail return values, but it provides a useful summary. The description covers the main behavioral aspects and parameter interactions. Missing details like timezone handling or pagination are minor given the tool's general purpose and the presence of 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%, so the description must fully explain each parameter. It does so effectively: specifying the YYYY-MM-DD format for date parameters, clarifying the behavior of include_body and expand_recurring, and noting defaults and interactions between parameters. This adds significant meaning absent from the schema.

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

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

The description clearly states the tool retrieves calendar events within a date range. It uses a specific verb (get) and resource (calendar events), making the purpose unambiguous. Although not explicitly distinguishing from siblings, the focused scope of date range filtering sets it apart from related tools like find_free_time or get_meeting_stats.

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 usage guidance within parameter explanations (e.g., when to use include_body vs expand_recurring), but it does not explicitly address when to choose this tool over siblings like find_free_time, create_meeting, or update_meeting. With many sibling tools, this lack of selection criteria is a gap.

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, and the description only says 'full body and details' without disclosing behavior like authentication needs, rate limits, or error handling for invalid item_id.

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?

Extremely concise: two sentences and an arg list. Every word adds value, with purpose stated 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 the simplicity and presence of output schema, the description is too sparse. It misses usage context and behavioral constraints, leaving the agent underinformed.

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

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

The schema has 0% description coverage, but the description adds meaning by specifying item_id is an 'Exchange ItemId'. However, it still lacks format or example.

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 gets a single email with full body and details, differentiating it from sibling tools like get_emails (plural) and delete_email.

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 like get_emails or search tools. The description does not mention context 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 carries full burden. It fails to disclose behavioral traits such as what happens if the email has no HTML body, whether the tool is read-only, authentication requirements, or error handling. The description is too minimal to adequately inform the 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 extremely concise: two sentences plus a parameter line with no wasted words. It front-loads the core purpose and maintains a clean structure.

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 (not shown) and one simple parameter, the description is mostly complete. However, it lacks guidance on edge cases like emails without HTML bodies or error scenarios, which slightly reduces 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 to the single parameter 'item_id' by explicitly stating it is 'The Exchange ItemId of the email to extract links from.' This goes beyond the schema's minimal title and type, which had 0% description 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 extracts all hyperlinks from an email's HTML body. The verb 'extract' and resource 'hyperlinks from email' are specific and distinct from siblings like 'get_email' (retrieves entire email) and 'get_event_links' (extracts links from 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?

The description implies usage for extracting links from an email, but does not explicitly state when to use this tool versus alternatives (e.g., get_email, get_event_links). No when-not or alternative guidance 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?

Discloses behavioral traits beyond the schema: 'include_body' is slower, 'ids_only' max limit raised to 500. No annotations are provided, so the description carries the burden. Does not mention error handling or authentication.

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?

Well-structured with an Args block. Each sentence serves a purpose, though the description is slightly lengthy due to parameter details. Front-loaded with the main 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 6 parameters and lack of annotations, the description covers essential behaviors. Output schema exists, so return format is not needed. However, missing guidance on error cases and prerequisites.

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 fully explains each parameter's meaning and effect (e.g., folder examples, ids_only behavior). Adds significant value 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 'Get emails from a mailbox folder' with specific verb and resource. It implicitly distinguishes from sibling 'get_email' (singular) by using plural 'emails'. The folder name examples clarify 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?

No explicit guidance on when to use this tool vs. alternatives like 'get_email' or 'delete_email'. The context is implied but not stated.

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

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

With no annotations, the description carries the full burden. It implies a read-only extraction but does not explicitly state side effects, failure modes (e.g., missing HTML), or whether it modifies the event. Basic 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 purpose, and contains zero wasted words. It is efficient and easy to parse.

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

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

Given the simple single-parameter tool and existence of an output schema, the description is mostly complete. It could hint at the output format (e.g., 'returns a list of hyperlinks') but is adequate.

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 adds clear meaning: item_id is 'The Exchange ItemId of the calendar event to extract links from', which clarifies the parameter's purpose and expected source.

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 (extract), resource (hyperlinks from a calendar event's HTML description), and distinguishes from siblings like get_email_links. It is 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 does not provide any guidance on when to use this tool versus alternatives (e.g., get_email_links for emails). No when-not-to-use or context given.

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

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

No annotations present, so description carries full burden. It clearly explains the read-only nature (listing), parameter effects (recursive vs shallow), and return structure. However, it does not mention authentication or permission requirements.

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 docstring-style format is clear but slightly verbose (Args/Returns). Could be slightly more concise, but the information is well-organized and front-loaded.

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

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

Given the tool's simplicity and presence of an output schema (though not shown), the description covers all aspects: purpose, parameter behavior, and return format. No gaps detected.

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 fully explains both parameters: parent_folder_id's default value and acceptable types, and recursive's boolean meaning. This adds significant semantic value 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?

Clearly states 'List mail folders from the Exchange mailbox.' The verb 'list' and resource 'mail folders' are specific, distinguishing it from sibling tools like create_folder or delete_folder.

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?

While it explains default behavior (top-level) and the recursive option, it does not explicitly state when to use this tool versus alternatives like search_calls_extensive or get_emails. No exclusion criteria given.

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

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

With no annotations, the description must disclose behavior fully. It describes analyzing calendar over a date range, accounting for recurring meetings, and returning weighted counts. However, it omits details like authentication requirements or any limits on data volume.

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

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

The description is concise and well-structured: a one-line summary, followed by a detailed explanation, then parameter descriptions, and finally return structure. 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?

The description covers inputs, behavior, and output structure adequately. The presence of an output schema reduces the need to detail return fields. However, it could mention that results are based on the authenticated user's calendar.

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 value beyond the input schema by specifying the date format (YYYY-MM-DD) and the default for top_n. Schema coverage is 0%, so the description is essential for understanding parameter 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: 'Build a connection matrix: who you meet with most often.' It uses specific verbs and resources, and distinguishes from siblings like get_meeting_stats by focusing on contact weighting and ranking.

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 the tool's functionality but does not explicitly state when to use it versus alternatives such as find_person or get_calendar_events. Usage context is implied rather than direct.

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

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

No annotations are present, so the description carries the full burden. It discloses that the tool uses GetUserAvailability and counts expanded recurring instances, and describes the return format. However, it does not state whether the tool is read-only, any required permissions, or potential side effects.

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 with a clear purpose sentence followed by a brief implementation note and structured Args/Returns sections. The only minor issue is the implementation detail ('Uses GetUserAvailability') which may not be necessary, but it does not detract significantly.

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?

An output schema exists, so return values are covered. The description adequately explains the parameters, purpose, and a key behavioral aspect (counting recurring instances). However, it lacks information on limitations, error conditions, or performance, which would be helpful for a stats aggregation tool.

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

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

The schema provides only titles and types with 0% description coverage. The description adds essential semantics: 'people' is a comma-separated list of names/emails, 'start_date' and 'end_date' are in YYYY-MM-DD format. This significantly clarifies usage 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 'Get meeting count statistics for one or more people over a date range.' It uses a specific verb ('Get') and resource ('meeting count statistics'), and defines the scope. This distinguishes it from siblings like 'get_calendar_events' which returns raw 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?

No guidance is provided on when to use this tool versus alternatives such as 'get_calendar_events' or 'find_meeting_time'. The description mentions the underlying API (GetUserAvailability) but does not explain trade-offs or exclusions.

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

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

With no annotations provided, the description fully discloses behavioral traits: browser-based SSO, 2FA mobile push, encrypted session cookies, and the two-call flow. It details the immediate return vs. second call pickup.

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 sections (Args, Returns) and front-loaded purpose. While slightly verbose, every sentence is informative and necessary for understanding the complex flow.

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

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

Given zero schema descriptions and no annotations, the description covers parameters, flow, encryption, and return value structure. It is complete for a tool with an output schema, though some edge cases (e.g., error handling) are not detailed.

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 compensates fully. It explains each parameter's role: master_password decrypts/encrypts, username is email for setup, password for setup. It adds behavior context for combined vs. solo use.

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 authenticates to Exchange OWA, handling credential setup and 2FA login. It distinguishes itself from siblings (e.g., check_session) by explicitly mentioning session expiry and first-use scenarios.

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 specifies when to call the tool ('session has expired or before first use') and outlines a two-call 2FA flow. While it provides clear context, it does not explicitly state when not to use it or compare directly with all siblings.

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 behavioral traits. It correctly identifies the operation as a state change (read/unread) and explains the boolean parameter. However, it doesn't mention authentication requirements, side effects, or any potential reversibility beyond the inherent toggling. Given the straightforward nature of the tool, this is adequate but not thorough.

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 plus a properly formatted argument list. The purpose is stated first, followed by parameter details. No irrelevant information is included.

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 low complexity of the tool and the presence of an output schema, the description is sufficiently complete. It covers the operation and parameter semantics. However, it could mention that the operation is immediate or provide a link to documentation for the ItemIds format.

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: it explains that 'item_ids' is a list of Exchange ItemIds and that 'is_read' defaults to True for marking as read. This clarifies the format and default behavior, compensating for the schema's lack of description.

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: marking one or more emails as read or unread. The verb 'mark' and the resource 'emails' are specific, and the tool is well-differentiated from sibling tools like delete_email, move_email, or reply_email.

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 (e.g., when to mark as read vs unread, or how to handle bulk operations). There is no mention of when not to use the tool or any 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 provided, and the description does not disclose side effects (e.g., whether the original email is removed from the source folder), permissions needed, or behavior if the target folder does not exist. It is minimally transparent.

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

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

The description is extremely concise, with two sentences and a clear argument breakdown. It is front-loaded and contains 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?

The description is adequate for a simple move operation, but given the lack of annotations and the presence of an output schema (not shown), it does not explain return values or elaborate on parameters. It is minimally 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?

Despite 0% schema description coverage, the description provides brief semantics for both parameters: item_ids are 'List of Exchange ItemIds' and target_folder is a folder name with examples. This adds value beyond the schema types.

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 moves one or more emails to a different folder, using a specific verb and resource. It distinguishes from sibling tools like delete_email, forward_email, and mark_email_read.

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

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

The description gives example folder names but does not explicitly state when to use this tool versus alternatives like delete_email or reply_email. It lacks guidance on when not to use it.

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

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

No annotations are provided, so the description carries full responsibility. It states the action (move folder to new parent) and mentions defaults and return value. However, it lacks details on side effects (e.g., impact on subfolders, permission requirements) that would increase 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 efficiently structured: a one-line purpose, followed by labeled Args and Returns. Every sentence adds value without redundancy. It is front-loaded and easy to scan.

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 (2 params, 1 required) and presence of an output schema, the description covers the essential behavior, parameters, and return format. It lacks error scenarios, but the output schema likely compensates. It is sufficiently complete for an 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?

With 0% schema description coverage, the description adds significant meaning. It explains folder_id as an ID from get_folders, and target_parent_folder_id as a destination with default and valid types (distinguished name or raw ID). This compensates well for the bare 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 starts with a clear verb+resource: 'Move a mail folder to a different parent folder.' This distinguishes it from sibling tools like rename_folder, delete_folder, and move_email, which have different actions.

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 explicit guidance on when to use this tool versus alternatives. While implication from the verb 'move' might differentiate from 'create' or 'delete', there is no mention of when not to use or which sibling to choose instead.

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?

Discloses that it renames a folder and returns success status with new folder ID, but doesn't mention permissions, reversibility, or error scenarios. No annotations provided.

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

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

Two short sentences plus structured Args/Returns sections. Every word adds value, 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?

For a simple rename with two parameters, description covers purpose, parameter sources, and return value. Output schema exists but description still explains return format.

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?

Adds context beyond schema: folder_id is an Exchange folder ID from get_folders, new_name is a display name. Schema descriptions are empty, so description compensates well.

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?

Clearly states verb 'Rename' and resource 'mail folder', distinct from siblings like create_folder, delete_folder, move_folder.

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?

Specifies folder_id source (from get_folders) and new_name purpose, but doesn't explicitly state when not to use or alternatives.

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

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

The description explains the reply_all behavior but does not disclose side effects (e.g., sent items, threading), required permissions, or error conditions. With no annotations, the description carries the burden; it is minimally adequate.

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: one opening sentence and a terse list of parameters. No unnecessary words, and the 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?

The description covers the basic operation and parameters, and an output schema exists to document return values. However, it lacks any behavioral context about success/failure, threading, or integration with the email system. For a simple tool, it is minimally sufficient.

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

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

All three parameters are described clearly: item_id as 'Exchange ItemId', body as 'Reply body text', and reply_all with conditional behavior. Since schema description coverage is 0%, the description compensates well by providing meaning beyond bare 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 'Reply to an email' with a specific verb and resource, and the parameter list reinforces the purpose. It distinguishes from siblings like 'forward_email' and 'send_email' by the action itself.

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

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

No explicit guidance on when to use this tool vs alternatives. It does not mention prerequisites, context, or scenarios where 'forward_email' or 'send_email' would be more appropriate.

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

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

With no annotations, the description carries the full burden. It discloses the action and return value but omits behavioral details like whether it sends a response email or updates calendar state.

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, front-loaded with the main purpose, and structured with Args/Returns. Every sentence adds value with no waste.

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 low complexity, no annotations, and an existing output schema, the description adequately covers parameters and return type. It lacks prerequisites or edge-case handling but is satisfactory.

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 the description compensates by explaining item_id as the ItemId, response as the type with three values, and message as optional. It adds meaning beyond the schema's type-only fields.

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 responds to a meeting invitation with specific verbs (accept, decline, tentative) and resource, distinguishing it from siblings like cancel_meeting or update_meeting.

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 what the tool does but does not explicitly state when to use it versus alternatives like cancel_meeting or update_meeting, nor does it provide when-not-to-use 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?

Discloses that is_html determines HTML rendering, but does not address success/failure behavior, rate limits, or side effects. No annotations exist to compensate.

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?

Well-structured with an 'Args:' section listing each parameter. Clear and focused, though slightly verbose for a tool with high schema coverage in other dimensions.

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

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

Covers all 7 parameters adequately, but lacks usage context relative to sibling tools. Output schema exists so return values are not required in description.

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?

Since schema coverage is 0%, the description adds crucial meaning: to/cc/bcc are comma-separated, importance defaults to Normal, is_html defaults to False and controls HTML interpretation.

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 'Send a new email' using a specific verb and resource. It distinguishes from sibling tools like forward_email and reply_email.

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 forward_email or reply_email. Lacks any context 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?

The description fully discloses the non-obvious behavior: internally cancels and recreates, preserves unchanged fields, and ignores change_key. Since no annotations are provided, this transparency is critical.

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 summary, internal behavior note, and parameter list. It is slightly lengthy but every sentence adds value. Could be marginally more 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 complexity (10 parameters, internal side effects), the description is complete: it covers all parameters, return value, and critical behaviors. No 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?

All 10 parameters are described in detail, including format hints (YYYY-MM-DD, HH:MM), omission behavior, and that attendee lists replace existing ones. This compensates for 0% schema description 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 'Update an existing calendar meeting' and details the internal behavior of cancelling and recreating. It effectively distinguishes from siblings like 'create_meeting' and 'cancel_meeting'.

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 to use the tool (to update a meeting) and notes that it replaces the old meeting. It implicitly warns that attendee lists are replaced. However, it does not explicitly state when not to use it or compare to alternatives like 'respond_to_meeting'.

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