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

The description adds a tip about silently accepting by setting sendResponse to false, but does not disclose other behavioral aspects such as modification of event status, requirement for organizer notification, or irrereversibility. Annotations already indicate destructiveHint: true, so the description adds marginal value.

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: one sentence plus a tip. It includes a visual cue (💡 TIP) and uses front-loaded key information. No superfluous content. Could be slightly more structured with a clear 'When to use' section.

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 information on prerequisites (e.g., authentication, calendar permissions), what happens on success (no output schema), and potential side effects beyond the tip. Given the complexity (5 parameters, nested objects), the description feels incomplete for an agent to fully understand 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?

The description provides a tip that adds meaning to the body parameter (e.g., comment and sendResponse usage) beyond the schema's property definitions. However, schema coverage is 80%, so the description does not need to compensate much; it adds useful context for the body parameter.

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

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

The description clearly states 'Accept the specified event in a user calendar' with a specific verb and resource, and the tip clarifies it's for meeting invitations, distinguishing it from sibling tools like decline-calendar-event or tentatively-accept-calendar-event.

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 explicit guidance on when to use this tool versus other calendar event actions (e.g., tentatively-accept, decline). The tip is about how to use the optional body, not about selecting between 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 repeats the action already implied by the name and annotations. It adds no new behavioral information (e.g., side effects, confirmation requirements, or data overwrite risks) beyond the existing destructiveHint. The only additional detail is the body format, which is parameter-related.

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 brief and front-loaded. The tip is clearly separated and provides essential formatting information without unnecessary verbosity.

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 combination of schema descriptions (86% coverage) and the description's body format example covers the essential usage. However, it lacks guidance on distinguishing this from similar Excel write operations and does not mention the confirm parameter's purpose (which is in the schema) or return 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?

The description adds a concrete example of the body.values array and the constraint that each inner array must match the table's column count. This goes well beyond the schema's generic range description, making the parameter usage clear.

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

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

The description clearly states the tool's function: 'Add Excel table rows' and 'Adds rows to a table.' It is specific to table rows rather than ranges, but it doesn't explicitly differentiate from insert-excel-range or other row manipulation 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 clear context for when to use this tool (adding rows to a table) but does not mention alternatives or exclusions, so it doesn't fully guide selection among sibling Excel 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?

Annotations indicate readOnlyHint=false and destructiveHint=true. The description adds transparency about the under-3MB constraint, the exact error on truncated base64, and the required @odata.type body structure. It does not mention the confirm parameter or any side effects, but it goes beyond annotations by explaining failure modes and size limitations.

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

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

The description is short but contains a malformed sentence: 'An attachment can be one of the following types: All these types...' It appears to cut off and doesn't list the types, causing confusion. The rest is efficient, but the structural issue reduces clarity.

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

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

The description covers the main usage context (size threshold, base64 format, example body) but lacks information about what the tool returns on success or how the messageId is used. It doesn't mention that it adds to a specific message, though that is implied. The incomplete type list also leaves a 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 80%, so baseline is 3. The description adds value by giving an example body structure with @odata.type and contentBytes, and emphasizing that contentBytes must be verbatim base64. This clarifies the key parameter beyond what the schema provides, especially since the body object schema is generic with additionalProperties.

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 creates a new attachment. It distinguishes from the upload-session sibling by size threshold. However, the sentence 'An attachment can be one of the following types' is incomplete and fails to list the actual types, which slightly weakens the purpose. The mention of 'messageId' is only in the schema, not the description.

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 provides usage guidelines: it states this is the only path for attachments under 3MB and directs to create-mail-attachment-upload-session for larger sizes. It also gives a critical tip about contentBytes being complete base64 to avoid failure, which is specific and actionable.

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

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

Annotations indicate destructive and not read-only. The description adds beyond annotations: moves event to Deleted Items, sends custom message, only organizer succeeds, recurrence handling via occurrence ID. No contradiction with annotations.

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

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

The description is well-structured with key purpose first, then details, then a tip. Slightly verbose but front-loaded and 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 no output schema, the description covers outcomes (cancellation message, event moved to Deleted Items), error cases, recurrence, and prerequisites (organizer only). Complete for agent usage.

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 high (80%). Description clarifies that body has optional Comment string and explains eventId usage. The tip repeats parameter info but adds value by summarizing body structure.

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 cancels a meeting for the organizer only and sends a cancellation message. It distinguishes from delete-calendar-event by explaining that cancel shows 'Canceled' in attendees' calendars, and notes that attendees calling get a 400 error and should use decline-calendar-event.

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 vs alternatives: 'Use this instead of delete-calendar-event when you want attendees to see Canceled' and advises attendees to use decline-calendar-event. It also clarifies it is for organizers only.

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

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

Annotations already indicate destructiveHint=true, but the description adds crucial detail beyond that by explaining the exact effects of each applyTo mode: 'Contents' wipes values but keeps formatting, 'Formats' resets styling but keeps values, and 'All' wipes both. This tells the agent precisely what gets destroyed, going beyond the annotation.

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 clear one-line summary followed by a tip that explains the key parameter and use case. Every sentence adds value, with no wasted words or repetition of schema details.

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

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

Given the rich annotations and schema, the description is largely complete. It covers the tool's purpose, usage context, and the nuanced behavior of the main parameter. The absence of an output schema means return values need not be documented. Minor gaps remain (e.g., no mention of the confirm parameter), but those are covered in schema descriptions.

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 descriptions for most parameters, but the body.applyTo parameter is not described in the schema. The description adds significant meaning by explaining the three allowed values and their behavioral implications. This fills a critical gap, even though schema coverage is high.

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

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

The description clearly states the tool's function: 'Clear an Excel range.' It elaborates on clearing contents and/or formatting, and distinguishes itself from sibling tools like delete-excel-range and update-excel-range by emphasizing resetting a section before a fresh write rather than overwriting cell-by-cell.

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 specific guidance: 'Use this to reset a worksheet section before a fresh write rather than overwriting cell-by-cell.' This clearly indicates when to use the tool, though it doesn't explicitly name alternatives. The context is sufficient for an agent to choose this over similar Excel range 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?

Annotations already declare readOnlyHint=false and destructiveHint=true, lowering the bar. The description adds significant behavioral context beyond annotations: the operation is asynchronous, returns 202 Accepted, and provides a Location header pointing to a monitor URL. This discloses the expected response pattern and async nature without contradicting the 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 front-loaded with the core purpose ('Copy a drive item') followed by a labeled TIP that adds async semantics, body format, response behavior, and use cases in four compact sentences. Every sentence contributes meaningful information, and the structure is 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 has no output schema, the description appropriately covers the return behavior (202 Accepted + Location header for async monitoring). It also addresses the complex nested body schema with an example. It could optionally explain how to consume the monitor URL or handle job completion, but for an async copy operation the essential context is present.

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 high (83%), providing a baseline of 3. The description adds a concrete body example ('{ parentReference: { driveId: '...', id: '...' }, name?: 'New Name.xlsx' }') that demonstrates how to structure the complex nested body parameter, which goes beyond the schema's property list by showing a realistic usage pattern.

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

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

The description uses a specific verb+resource ('Copy a drive item') and elaborates with 'Asynchronously copy a file or folder to a new location and/or name.' It clearly distinguishes from the sibling move-rename-onedrive-item by framing the operation as creating a copy, and the template-cloning use cases reinforce the copy semantics.

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 with 'Ideal for duplicating templates... bulk file provisioning, or preserving an immutable snapshot of a working file,' giving concrete usage scenarios. It does not explicitly name alternatives or exclusions relative to move-rename-onedrive-item, but the use cases strongly imply when copying is appropriate.

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

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

Describes return value (newly created message with new id) and body format. Annotations already indicate write operation, so description adds useful context beyond 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?

Concise, front-loaded with action, uses bullet/tip format effectively. 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?

Covers key aspects: action, parameters, return value, comparison to sibling. Could include more details on return type but sufficient given no 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?

Adds significant value over schema: explains DestinationId format with examples (inbox, archive, junkemail), clarifies messageId parameter naming and origin, and mentions optional 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?

Clearly states it copies a message to a folder, specifies destination via DestinationId, and distinguishes from move-mail-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?

Explicitly contrasts with move-mail-message: 'For moving instead of copying, use move-mail-message.' Provides tip on 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 contradicts the annotation 'destructiveHint: true' because creating a calendar is typically not destructive. It also fails to mention any side effects, confirmation requirements, or the fact that a 'confirm' parameter may be required when the confirmation gate is enabled. No behavioral details beyond the basic action are 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 concise, consisting of two sentences. It is well-structured with a clear statement followed by a helpful tip. No unnecessary words or redundancies.

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?

While the description covers the essential idea of creating a calendar, it lacks context about required fields, typical usage patterns, or what happens after creation. The schema is very large, and the description offers only a minimal example. It is complete enough for a simple action but not fully comprehensive given the tool's complexity.

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

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

The description provides a simple example of the body ({ name, color }) and lists valid color values, which adds some meaning beyond the schema. However, it does not clarify the purpose of the other parameters (confirm, includeHeaders, excludeResponse) or explain the structure of nested objects. The schema already describes most properties, so the incremental value is modest.

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 the resource ('a new calendar for a user'). It is specific enough to distinguish from sibling tools like 'list-calendars' or 'update-calendar'.

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, nor any prerequisites or conditions. The description is purely declarative and does not help an agent decide between creating a calendar and other calendar 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?

Annotations already mark this as mutating (destructiveHint=true, readOnlyHint=false), so the description need not restate that. It adds value by detailing what the operation does beyond creation: it sets fields, supports online meetings and recurrence, and the tip clarifies a critical behavioral constraint (resolve emails via list-users). No contradiction with annotations; the description safely adds 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 exceptionally concise: two sentences plus a standalone tip. Purpose and key capabilities are front-loaded, and the tip is clearly separated and highlighted. Every word earns its place, with no fluff or repetition of the schema.

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

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

For a mutation tool without an output schema, the description covers the essential inputs and the key decision of resolving attendees. It does not mention the confirm gate behavior (handled in schema) or side effects like sending invitations, but those are either documented in the schema or implied by the operation. The resource list and the user-email tip together give an agent enough to invoke it correctly in most scenarios.

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 lists the principal resource fields (subject, start/end, time zone, location, body, attendees) and capabilities (online meetings, recurrence), which adds meaning beyond the raw schema. Schema coverage is 75% (likely covering the main event fields and control params), so the description complements but does not fully replace the schema's details. Control parameters (confirm, includeHeaders, excludeResponse) are not mentioned, but those are operational knobs rather than core event data.

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

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

The description clearly states a specific verb ('Create (schedule)') and resource ('new calendar event — a meeting or appointment') on the user's calendar. It lists the key attributes (subject, start/end times, time zone, location, body, attendees) and capabilities (online meetings, recurrence), distinguishing it from siblings like update-calendar-event, delete-calendar-event, and get-calendar-event without ambiguity.

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

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

The description includes an explicit, highly actionable tip: do not guess recipient email addresses and instead use the list-users tool. This directly guides agent behavior and prevents a common failure mode. However, it does not explicitly signal when to prefer create-specific-calendar-event over this general variant, so the when-to-use guidance is strong but not exhaustive.

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

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

Annotations indicate destructiveHint=true, which is consistent with creating a new folder. The description adds that the returned folder ID can be used with other tools, providing extra behavioral context beyond the 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 short (three sentences plus a tip), front-loaded with the main purpose, and every sentence adds value. No wasted words.

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

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

Given no output schema, the description explains that the returned contactFolder has an id usable with other tools, which is helpful. However, it doesn't fully specify the return object structure, but it's adequate for a simple create operation.

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 high (80%), so the baseline is 3. The description adds a concrete example of the body format ('displayName': 'Sub-folder name') and mentions the 'parent id' for contactFolderId, providing marginal extra value.

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

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

The description clearly states the tool creates a contact folder as a child of a specified folder, with an option to create under the user's default folder. It distinguishes from sibling 'create-contact-folder' by emphasizing the child relationship.

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 tells users to 'Use list-contact-folders to discover the parent id' and provides a tip about the body structure. It doesn't explicitly say when not to use this tool, but the context is 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?

Annotations already mark destructiveHint=true. The description adds that it creates under default folder or specified parent, and returns the created folder with id. However, it does not clarify the contradiction about parent folder usage, nor disclose any side effects beyond creation. The behavioral transparency is adequate 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 short, front-loaded with the main action, and includes a tip. Every sentence adds value, and there is no repetition or 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 complexity (nested objects, 4 parameters, no output schema), the description is incomplete. It only provides a minimal example for the body and does not explain the full body structure or the behavior of the confirm parameter. The tip briefly mentions return value, but more detail would be beneficial.

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 75%, so baseline is 3. The description adds a concrete example ('Body: { displayName: 'Family' }') which adds meaning beyond the schema's property descriptions. It does not elaborate on other parameters like confirm or includeHeaders, but those are already described 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 it creates a new contact folder under the user's default contacts folder. It mentions it can also create as a child of any specified folder, but this is contradicted by the tip which recommends using create-contact-child-folder for sub-folders, creating ambiguity. Overall, the main purpose is clear.

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 provides when to use (create top-level folder) and when to use an alternative (create-contact-child-folder for sub-folders). This helps the agent distinguish between sibling tools.

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

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

The annotations mark this as destructiveHint: true, but the description describes a creation operation ('Add a contact') which is not destructive. This contradiction obscures the actual side effects. The description also does not disclose any other behavioral traits such as required permissions or response behavior beyond what the schema already states, so transparency is poor.

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 compact and well-structured, consisting of two concise sentences plus a brief tip. It avoids redundancy and front-loads the core action and target, followed by usage differentiation and a retrieval hint. No filler or unnecessary details are 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?

For a create operation with no output schema, the description covers the essential context: what the tool does, when to use it over the alternative, and how to supply the necessary parameters. It lacks explicit mention of success/failure response or side effects, but given the simplicity and existing schema documentation, it is nearly complete. The contradiction with the destructive hint 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 'contactFolderId' parameter by clarifying the naming convention ('Pass it under the name 'contactFolderId', not as 'id'') and referencing the source of the value. It also summarizes the 'body' parameter as a contact resource. However, for the 'confirm', 'includeHeaders', and 'excludeResponse' parameters, the description offers no additional insight beyond the schema descriptions, which are already present.

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

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

The description clearly states the action ('Add'), the target ('a contact'), and the location ('to the root Contacts folder or to the contacts endpoint of another contact folder'). It also names the sibling tool it differentiates from, making the purpose unambiguous.

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

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

It explicitly contrasts with create-outlook-contact, stating when to use this tool versus the alternative ('writes to the default folder only; use this when organizing contacts into named folders'). It also provides a retrieval hint ('Get the folder id via list-contact-folders').

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

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

Annotations already signal a mutating readOnlyHint=false and destructiveHint=true, so the bar is lower. Beyond that, the description discloses the critical non-obvious behavior 'saved, not sent' — an agent might otherwise assume the call sends the email. This is a genuinely valuable behavioral disclosure. Remaining gaps are minor: no mention of return value, errors, or the confirm gate, but the confirm gate is documented in the schema.

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

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

Three short sentences, with the core purpose front-loaded first and the routing guidance placed last. The second sentence listing fields is mildly redundant with the rich schema, but it is still helpful as a quick summary of what the caller should worry about. No filler or repetition of annotation content.

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

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

For a tool with a large nested input schema and no output schema, the description covers the essential aspects: what is created, where it lands, what fields matter, and the saved-not-sent behavior. The main omission is that there is no explicit note about what the call returns (e.g., the created message with its id), which is useful since the output schema is absent.

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

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

Schema description coverage is 75%, so most parameters are already documented inside the input schema itself. The description adds the context that subject, body, toRecipients, ccRecipients, and importance are the fields the caller would typically populate, but doesn't explain structural concepts such as recipient shapes or content type. That is a small reinforcement, not a substantial addition, so the baseline 3 is appropriate.

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

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

The description states a clear verb (create) plus a precise resource (a draft Outlook message in the signed-in user's Drafts folder) and enumerates which fields can be set. It also separates itself from send-oriented tools, so an agent can distinguish it from siblings such as send-mail, send-draft-message, and create-reply-draft without opening their schemas.

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

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

The third sentence explicitly routes the agent: 'The draft is saved, not sent — use send-mail to send a message directly, or send the draft afterwards.' That names the primary alternative with the selecting condition (the distinction between creating vs. sending). The only gap is that it doesn't name send-draft-message explicitly as the specific tool to send the draft afterwards, nor does it mention the forward/reply draft siblings, leaving a small part of the routing to inference.

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 presents the operation as a benign 'create' action that returns a short-lived URL, yet the annotations set destructiveHint=true. This is a direct contradiction: no mention of destructive effects or reasons for the destructive flag. The description also fails to explain why a preview creation would be considered destructive.

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 compact and front-loaded with the main action. The emoji and tip format are slightly informal but every sentence adds useful information, including body structure, return values, and a practical use case.

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?

Without an output schema, the description still explains return values, body options, and short-lived nature, which is good. It omits discussion of the destructive hint and confirm gate, but those are already exposed via annotations and parameter descriptions, so the overall picture is adequate for a moderately 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 coverage is 83%, and the description adds the 'viewer' option not present in the schema, and clarifies that return values are getUrl and postUrl. These additions meaningfully supplement the schema descriptions, which already cover driveId and driveItemId 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 it creates a drive item preview and explains that it generates a short-lived embeddable preview URL for files. It distinguishes itself from sibling tools like share-link or download-url by focusing on inline previews for summary emails or chat 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?

Provides a concrete use case: 'surfacing inline previews in summary emails or chat messages without needing the recipient to open the file.' It does not explicitly exclude alternate tools, but the context is clear enough for an agent to decide when 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?

Description adds context like no email sent and inheritance, but annotations have destructiveHint=true while the operation is not destructive (it creates or returns existing link). This contradiction reduces transparency. No explanation of destructive consequences.

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 efficient, with a tip and clear structure. It includes key information without unnecessary words, but could be slightly more concise in the tip section.

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

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

Given no output schema, description informs about return (permission with link.webUrl) and mentions inheritance. Covers main use case, but lacks details on error conditions and full response structure.

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 83%, and description adds value by providing enums for type and scope, and clarifying the effect of body fields (e.g., no email). However, it omits some schema fields like message and recipients, so not fully complete.

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 explicitly states the tool creates a sharing link for a driveItem, distinguishes between creating a new link and returning an existing one, and differentiates from the sibling tool 'share-drive-item' by noting it does not send invitations.

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 clear guidance: 'Pair with share-drive-item when you want to grant explicit access; use this when you only need a URL to paste into a doc/email/chat without triggering OneDrive notifications.' Also explains behavior when link already exists.

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

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

Annotations already indicate destructiveHint=true. The description adds no new behavioral info beyond the fact that it creates a chart.

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 lacks substantive 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 is too brief for a tool with 7 parameters and no output schema. It fails to convey important context about the chart creation process.

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 86%, so the schema already documents most parameters. The description adds no additional parameter meaning.

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 'Creates a new chart.' clearly states the action and resource, but does not differentiate from sibling tools like create-excel-table.

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 or context for use.

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

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

Annotations already indicate destructiveHint=true and readOnlyHint=false. The description adds behavioral details: the range address determines the worksheet, errors on invalid address or overlap. It does not explicitly state it modifies the workbook, but creation implies modification. The addition of error conditions adds transparency beyond 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 concise: two short paragraphs plus a tip. The first sentence immediately states the main action. The tip is clearly formatted and adds crucial prerequisite information. 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 covers purpose, errors, and prerequisite relationship. However, it lacks information about the return value (e.g., the created table object or success status). Since there is no output schema, the description should explain what the tool returns. This is a notable gap given the tool's complexity.

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

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

Schema description coverage is high (86%), but the description adds value by explaining the address and hasHeaders parameters through an example and noting that the address determines the worksheet. This goes beyond what the schema provides. For parameters already well-documented in schema, the description still offers practical 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 clearly states it creates a new table, defines the role of the address parameter, and distinguishes itself from related sibling tools like add-excel-table-rows by noting it is a prerequisite. The tip provides a concrete example, reinforcing the purpose.

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

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

The description explicitly states when to use the tool: required before add-excel-table-rows, update-excel-table-row, or delete-excel-table-row on a plain-cells sheet. It also mentions error conditions (invalid address, overlapping table) which guide when not to use. This provides clear usage context.

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

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

Annotations indicate destructiveHint=true, so the description's mention of creating and updating overrides aligns with this. The description adds context about the update behavior (renaming a sender) and the required body structure, going beyond the annotation hints. No contradictions found.

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 five sentences, starting with the primary purpose. It includes a tip and important notes without being overly verbose. The structure is logical, though some redundancy (e.g., the tip repeats the body format) could be trimmed.

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 purpose, required fields, update behavior, and address resolution. However, it does not mention what the response looks like after creation, error cases, or permissions. Given no output schema, more detail on return values would be beneficial. The openWorldHint annotation allows some leeway.

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

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

The schema covers 75% of parameters. The description adds a concrete example of the body object (classifyAs and senderEmailAddress with fields) and specifies that classifyAs must be 'focused' or 'other'. This provides practical guidance beyond the schema's enum 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 creates a Focused Inbox override for a sender identified by an SMTP address, specifying that future messages will be consistently classified. The verb 'create' and resource 'focused-inbox-override' are specific, and the tool is distinct from siblings like 'create-draft-email' or 'create-planner-task'.

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

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

The description provides clear context: it tells the agent to resolve the sender's address using list-users or recent mail headers, and explains that if an override already exists, the POST updates it. However, it does not explicitly state when not to use this tool or mention alternatives.

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

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

Annotations already include destructiveHint=true and readOnlyHint=false, signaling a mutation. The description adds valuable context that no email is actually sent, which is not present in annotations. This helps the agent understand the side effect boundary (creation vs. sending) without contradicting the 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 short and front-loaded with the core action. The tip repeats 'Create a forward draft' verbatim, adding slight redundancy, but otherwise the structure is efficient. No wasted sentences beyond the repetition.

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

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

The tool deals with a complex body object and lacks an output schema. The description does not explain what the body should contain or how to reference the original message, though the schema provides some coverage. Given the complexity, more guidance would help, but the description is not severely lacking, so a 3 is fair.

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 80%, which is high, so the schema documents most parameters (e.g., messageId, confirm, includeHeaders, excludeResponse) with descriptions. However, the description adds no further parameter explanation, and the complex body object (with Comment, Message, ToRecipients) has no description in the schema either. Since the description does not compensate for gaps, a baseline 3 is appropriate.

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

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

The description clearly states the action: 'Create a forward draft', and immediately clarifies that it does not send. This distinguishes it from sibling tools like forward-mail-message, which actually sends, and create-reply-draft, which is a different kind of draft. The verb and resource are explicit.

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 tip provides a clear use case: 'Useful when user wants to review before sending.' This implies when to choose this tool over forward-mail-message, but it does not explicitly name alternatives or state when not to use it. It gives context but lacks explicit exclusions or comparisons.

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 that the tool returns an upload URL for subsequent PUT operations, clarifying that it does not upload the file itself. This adds behavioral context beyond the annotations (which only mark destructiveHint), though it does not elaborate on confirmation requirements or 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 verbose and repetitive, restating the same size threshold and upload flow multiple times, including a redundant TIP section. This hurts clarity and readability, making it less concise than ideal.

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 core flow (create session, get URL, then PUT) but omits mention of the confirm parameter's role and confirmation requirements, which is relevant given the destructiveHint annotation and the schema. It is sufficient for basic use but lacks completeness for a complex multi-step operation.

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

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

The schema already provides detailed descriptions for the body, messageId, and confirm parameters, with 80% coverage. The description does not add new parameter-specific semantics; it only reiterates file size limits that relate to the overall usage rather than individual 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 creates an upload session for attaching a file to an Outlook item (message or event). It specifies the target resource and the unique action (creating a session), and distinguishes it from the alternative for smaller files (add-mail-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?

The description explicitly gives usage criteria: files between 3 MB and 150 MB should use this tool, while smaller files should use the POST operation on attachments. This provides clear when-to-use vs. when-not-to-use guidance, including a named 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?

Annotations already indicate mutation (readOnlyHint=false) and potential destructiveness (destructiveHint=true), so the description does not need to repeat that. It adds the nuance that 'isHidden' can only be set on creation, but does not disclose other behavioral traits like 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 extremely concise: two sentences plus a tip, with no wasted words. It is front-loaded with the primary purpose and immediately 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?

For a create tool with no output schema, the description does not explain the return value or error conditions. However, given the complexity of the input schema, the tip provides essential context about finding the parent ID, making it fairly complete for typical usage.

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 80% schema description coverage, the schema already documents most parameters. The description adds value by highlighting the 'isHidden' property must be set on creation and providing the tip about parent folder ID, though it does not cover all 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 'create a new child mailFolder' and 'Creates a subfolder inside an existing mail folder,' which provides a specific verb and resource. It distinguishes itself from sibling tools like 'create-mail-folder' by explicitly specifying it is for child 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 gives a tip to use 'list-mail-folders' or 'list-mail-child-folders' to find the parent folder ID, guiding proper usage. However, it does not explicitly mention when not to use this tool or provide alternatives like 'create-mail-folder' for top-level folders.

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

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

Annotations already indicate non-readOnly and destructiveHint. The description adds behavioral insight about isHidden being settable only on creation, but lacks further context on side effects or permissions.

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 plus a tip. Front-loaded with purpose, 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?

Covers creation context and cross-references siblings well. Lacks output description but matches tool complexity.

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

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

Schema coverage is high (75%), so baseline is 3. The description adds a tip about isHidden, but the schema already describes most parameters adequately.

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

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

The description clearly states the tool creates a new mail folder in the root folder, distinguishing it from the sibling tool create-mail-child-folder for subfolders.

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 advises when to use this tool (top-level folder) and when to use alternatives (create-mail-child-folder for subfolders, list-mail-folders to find IDs).

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 states that Outlook carries out the specified actions when an incoming message meets the conditions, which clarifies the operational behavior. Annotations already indicate destructiveHint=true and readOnlyHint=false, so the agent knows this is a mutation, and the description aligns without contradiction. It does not elaborate on side effects or permanence beyond the core behavior, but annotations cover the safety profile.

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 sentence, a tip section, and a sample body. It is not overly verbose and front-loads the core purpose. The inclusion of an example is justified given the complexity of the body object, and the formatting with a line break and emoji improves readability.

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 of the tool with multiple nested objects and many condition/action properties, the description provides a sample body and lists the available actions, which is helpful. The schema extensively documents individual properties, so the description does not need to repeat all that. However, it does not mention what the tool returns on success (e.g., the created messageRule object), which could be a minor gap since no output schema is provided.

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

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

The schema covers 80% of parameters with descriptions, so the baseline is high. The description adds a practical example body showing how to structure displayName, sequence, isEnabled, conditions, and actions, which is not in the schema. It also clarifies that mailFolderId must be passed under that name, not as 'id', and points to list-mail-folders for obtaining it, adding semantic clarity 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 action (create), the resource (messageRule object), and the context (incoming messages in the user's Inbox). It distinguishes itself from sibling tools like update-mail-rule and delete-mail-rule by focusing on creation and the conditions/actions involved. The verb-resource pairing 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 provides clear guidance on when to use the tool, including a tip to use the Inbox folder ID from list-mail-folders for inbox rules. It also includes a concrete body example with required fields, which helps the agent construct a valid request. However, it does not explicitly contrast with alternatives like update-mail-rule or state scenarios where this tool should not be used.

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

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

Annotations already indicate a write operation (readOnlyHint: false) and destructiveHint: true, so the bar is lower. The description adds the effect (shares primary calendar or delegates) and provides an example body, plus the return value includes an id for later modifications. It does not contradict 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?

Two concise sentences plus a tip. The purpose is front-loaded, and the tip provides a concrete example and return information without unnecessary verbosity. Every word 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?

Covers purpose, example body, return value, and relationship to update/delete siblings. It doesn't explicitly state that the tool targets the user's primary calendar only, but that is implied by the naming convention (create-my-calendar-permission) and sibling tools. No output schema, but the return is described adequately.

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 75%, so the description doesn't need to carry the full burden. The tip provides an example body with typical role values, but the enumerated roles listed are an incomplete subset of the schema's full enum (missing 'none', 'freeBusyRead', etc.), which could slightly mislead. However, the schema itself has the full list, so this is not a major issue.

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

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

The description clearly states a specific verb and resource: 'Create a calendarPermission resource to specify the identity and role of the user with whom the specified calendar is being shared or delegated.' It distinguishes itself from update/delete siblings by mentioning the returned id is used for those operations. The tip clarifies it shares the user's primary calendar or sets up a delegate.

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 tip explains when to use the tool (sharing primary calendar, delegating) and directs the agent to use list-users to resolve email addresses. It also notes the return id is used by update and delete tools, providing chaining context. It doesn't explicitly state when not to use, but the intent is 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?

Annotations indicate readOnlyHint=false (it's a write), destructiveHint=true. The description adds value beyond annotations by explaining conflict behavior options (rename, replace, fail), which is behavioral context the annotations don't provide. It doesn't contradict annotations. Also includes a 'confirm' parameter for destructive gate, which aligns with destructiveness. Slight deduction for not mentioning other side effects, but solid overall.

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: one opening sentence, a tip line, and then structured guidance. The most critical information (what body must contain, conflict behavior options) is front-loaded and formatted clearly. No wasted words; each part has purpose.

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

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

For creating a folder, the description covers essential inputs: driveId, driveItemId, body requirements, conflict behavior. The schema is rich and well-covered. It could mention return values (since no output schema), but for creation tools, this is often obvious. Minor gap: unclear what happens on success (returns created folder item), but given the tool's simplicity, this is quite complete. Not a 5 because it lacks explicit mention of success 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 83%, high. The description adds critical meaning beyond schema: it explicitly says the body must include 'name' and 'folder' fields, and explains the conflictBehavior mechanism, which is not in the schema. This compensates well for the complexity of the body object. A 4 because it's genuinely helpful but could still deepen details like error handling.

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 exactly what the tool does: 'Create a OneDrive folder' and specifies it creates inside a drive item. It clearly identifies the verb, resource, and context, and distinguishes from siblings like move-rename-onedrive-item and delete-onedrive-file which have different purposes.

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 instructs what the body must include ('name' and 'folder' fields) and how to use '@microsoft.graph.conflictBehavior' to control name conflicts. It implies the context of creation (inside a specified drive item) and is clear about required parameters, preventing incorrect usage.

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

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

Annotations already mark as destructive (destructiveHint=true). Description adds the uniqueness constraint on displayName, which is useful but not comprehensive—does not mention error behavior on duplicate names or side effects like sharing or default notebook creation.

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 plus tip), but the tip is partially redundant. Front-loads the core purpose. No unnecessary detail, though it could be slightly tighter.

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

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

No output schema and description does not explain return value. Does not mention the confirm gate parameter, which is important for a destructive operation. Lacks details on user or scope (e.g., current user's notebooks). Missing information about prerequisites or post-conditions.

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 75% and describes body extensively. Description adds an example body format and the uniqueness rule for displayName, providing modest value beyond the schema. The confirm and other headers are not mentioned.

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?

States 'Create a new OneNote notebook' with a tip clarifying the body format and uniqueness constraint. Clearly identifies the resource and action, though it does not differentiate from siblings like list-onenote-notebooks.

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 (e.g., create-onenote-section, create-onenote-page). Does not specify context such as user authentication or typical workflow order.

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?

Beyond annotations (destructiveHint=true, readOnlyHint=false), the description discloses a critical behavior: the body must be a full HTML document; otherwise, it fails silently or creates malformed pages. This is valuable context that helps the agent avoid errors.

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 single sentence for the main purpose, followed by a clarification for section targeting, and a highlighted tip for the body format. Every sentence adds value without 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?

The description covers how to create pages and the required body format, but it does not mention what the response contains (e.g., the created page object), which is important for an agent to process the result. Given no output schema, this 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?

The input schema has 4 parameters, with descriptions for 3 (confirm, includeHeaders, excludeResponse) but no description for the 'body' parameter. The description compensates by specifying that the body must be a full HTML document, adding essential semantic information 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 tool creates a new OneNote page in the default notebook's default section, specifies the endpoint, and distinguishes from sibling tools by noting that this tool is only for the default notebook (with a workaround for other sections via query parameter).

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

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

The description provides explicit guidance on when to use this tool (default notebook) and how to target a different section using the sectionName query parameter. It mentions that for other notebooks, you should create pages in a specified section, but does not name a specific sibling tool as the alternative, which would improve clarity.

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

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

Annotations already declare destructiveHint: true and readOnlyHint: false. The description adds a payload example but does not elaborate on side effects, permissions, or the actual creation process. No contradiction with annotations.

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

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

The description is brief (one sentence plus a tip) and front-loaded. No extraneous text, though the tip could be integrated more concisely.

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

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

The tool has 5 parameters, no output schema, and nested objects. The description covers the basic purpose but omits details about return values, error scenarios, or required permissions. Adequate but not comprehensive.

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 high (80%), and the description adds value by showing an example body structure with 'displayName'. This clarifies the expected content beyond the schema's property 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 verb 'Create' and the resource 'onenoteSection', specifying 'in the specified notebook'. It distinguishes from sibling tools like 'create-onenote-notebook' and 'create-onenote-section-page' through the target resource.

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 (e.g., when to use a section group). The tip provides an example body but does not clarify 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?

Annotations already indicate destructiveHint=true, so the description doesn't need to repeat that. The description adds a useful behavioral note: the body must be a full HTML document or it fails silently. However, it doesn't disclose other potential side effects or error states beyond the tip. Overall, minimal extra value beyond annotations.

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

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

The description is extremely concise: one sentence stating purpose plus a tip about the body parameter. No unnecessary words, front-loaded with key information. The tip is formatted clearly with an emoji for attention.

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 create operation with no output schema, the description provides the essential inputs (section, body) and a critical constraint (full HTML). It does not mention return values or whether the operation is idempotent, but those are not strictly required. The tip about silent failure is valuable. Overall, sufficiently complete given the tool's complexity.

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

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

The description explicitly clarifies that the 'body' parameter must be a full HTML document, which is critical and not obvious from the schema alone. Schema coverage is 80%, so the description compensates with this key detail. Other parameters like 'onenoteSectionId' are well-described in the schema, so no further info needed.

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

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

The description clearly states it creates a new page in a specified section. The verb 'Create' and resource 'page in specified section' are explicit, and the tool name reinforces this. It distinguishes from sibling 'create-onenote-page' which likely creates a page without specifying a section.

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 'create-onenote-page' or 'create-onenote-section'. No mention of prerequisites or when not to use it. The tip about HTML body is helpful but does not address usage context.

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

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

The description adds context about color mapping and case sensitivity beyond annotations (readOnlyHint: false, destructiveHint: true, openWorldHint: true). However, the destructiveHint annotation seems inconsistent with creation, but the description does not contradict it directly.

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 clear sentences plus a tipped paragraph. Information is front-loaded and no extraneous content.

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

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

Missing description of the return value (no output schema). It states it creates an object but doesn't indicate the response includes the created category. Adequate for basic use but incomplete for an agent needing to know what to expect.

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 75% schema coverage, the description enhances the body parameter by mapping color enums to human-readable names and emphasizing uniqueness of displayName. It does not explain confirm, includeHeaders, or excludeResponse, but schema covers them.

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 'Create an outlookCategory object in the user's master list of categories,' providing a specific verb and resource. It distinguishes from sibling tools like list-outlook-categories 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 (e.g., list-outlook-categories or other create tools). The tip only explains the body format, not usage context.

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

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

Annotations already signal a non-read-only, destructive mutation, so the description is not expected to repeat that. It adds the useful scoping detail of root vs other folder, though it does not mention idempotency, confirmation behavior, or side effects beyond what the confirm parameter already covers.

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

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

The description is one concise, front-loaded sentence with no filler. It communicates the core action and target in under 20 words, and every word 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?

The input schema is large and nested, and there is an overlapping sibling create-contact-in-folder, yet the description never explains how to target a non-root folder or what distinguishes this variant. There is also no output schema and no mention of return values or required body fields, leaving important call details to inference.

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 no parameter-level meaning, but the schema carries 75% coverage, including rich descriptions for the nested body properties and the confirm/includeHeaders/excludeResponse parameters. Since the schema already documents the parameters sufficiently, the description does not need to restate them.

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 the exact operation ('Add a contact') and the two target locations: the root Contacts folder or another contact folder's contacts endpoint. It is clear about the resource and action, but it does not explicitly distinguish this from the sibling create-contact-in-folder, so it is not fully 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?

There is no guidance on when to choose this tool over create-contact-in-folder or update-outlook-contact, and no mention of prerequisites or exclusions. The folder-target wording provides only a weak contextual hint for routing an agent.

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

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

Annotations already flag this as a write (readOnlyHint=false) and destructive (destructiveHint=true), and the description adds no behavioral context beyond that — no mention of confirm-gate interaction, idempotency, or side effects. For a create operation that modifies data, the description should at least acknowledge that creating the new object has persistent consequences.

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

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

The single sentence is succinct and front-loaded, with no redundant filler. The brevity is a sign of under-specification, which is penalized in other dimensions, but as a structural matter it is appropriately terse for a single-sentence definition.

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

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

For a destructive, open-world tool with a deeply nested body schema and no output schema, one sentence is insufficient context. It doesn't say the bucket must belong to an existing plan, what happens if the client supplies a conflicting id, or what the caller should expect after a successful creation.

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

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

The schema covers 75% of parameters with descriptive text, including body, planId, confirm, and the nested task fields, so the schema itself carries most of the semantic weight. The description adds nothing about how the parameters combine (e.g., that the bucket needs a valid planId or that body is required).

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?

States a specific verb (Create) and resource (plannerBucket object) plainly, so an agent can identify what the action is. However, it is essentially a restatement of the tool name and provides no distinguishing detail about what a planner bucket is relative to other Planner 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?

Offers no guidance on when to invoke this tool instead of siblings like create-planner-task, list-plan-buckets, or update-planner-bucket. It also fails to mention the prerequisite context (e.g., an existing plan to attach the bucket to) or when the confirm gate applies.

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 does not disclose any side effects, confirmation requirements, or other behaviors beyond the annotation's destructiveHint flag. It adds no additional transparency beyond the metadata.

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

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

The description is a single concise sentence that is well-structured and to the point, avoiding any unnecessary verbosity.

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 complex nested body object and the absence of an output schema, the description lacks contextual information about required properties, special considerations, or the intended use of the task creation. It is minimal and insufficient for complete understanding.

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 no meaning to the parameters. While the schema has a coverage of 75%, the top-level body parameter is not described and the tool description does not mention any parameters.

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

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

The description clearly states the action 'Create' and the resource 'plannerTask', which is specific enough to distinguish it from other create tools in the sibling list.

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

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

No guidance is provided about when to use this tool versus alternatives, nor any context for its typical usage scenarios. The description is purely a one-liner without usage hints.

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

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

Annotations say readOnlyHint=false and destructiveHint=true; the description doesn't contradict those, and it goes well beyond them by disclosing the beta status, BETA Graph API volatility, exact account/authentication limits, environmental cloud limitation, and the no-ETag requirement. This substantially reduces the risk of misinvocation.

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 dense but every sentence earns its place: operation, usage context, body format, optimistic caveat, authentication restrictions, and cloud limitations. It is front-loaded with the core action and the practical tip, and doesn't merely repeat the schema.

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 fully explains the operational context, supported message content, mentions, auth/profile constraints, and beta flags, making tool selection and invocation correct without prior knowledge. A brief note about what the create call returns would be nice, but the absence of a return-value shape doesn't block the intended call.

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 about 80%, so the baseline is 3, but the description adds real parameter-level value by giving a compact body grammar: content is 'plain text or sanitized HTML', mentions are optional and contain user-id/position/mentionType. It lets an agent compose the core body without fully parsing the nested schema structure.

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 the action ('Create a new plannerTaskChatMessage'), the target ('on a plannerTask'), and the context ('task chat' vs the legacy conversationThreadId comment). This makes the tool's purpose unmistakable and distinct from the related planner task message list/delete/update 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 TIP clearly says when to use it: to post per-task updates teammates will see, using the modern task chat rather than the retired classic comments experience. It also gives hard boundary conditions (delegated work/school accounts, no application permissions, no sovereign clouds). It doesn't explicitly name a sibling tool as the alternative, but the legacy path is not a sibling tool here, so the guidance is strong.

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?

Beyond the annotations (readOnlyHint=false, destructiveHint=true), the description discloses key behaviors: the HTTP 400 error for conflicting parameters, that supplying Message.body replaces the whole draft body (dropping quoted history), that signatures are added only by the Outlook client, and that the draft can be updated later. This is extensive and goes well beyond what annotations already provide.

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 long but well-structured with bullet points and a tip section. It front-loads the primary purpose, then logically breaks down JSON and MIME usage, then adds important caveats. Every sentence earns its place; the length is justified by the complexity of the operation.

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 thoroughly covers error conditions, format choices, and behavioral nuances. It does not mention the return value (e.g., the created draft message object), but no output schema exists, and the description provides enough for an agent to correctly invoke the tool. Minor gap: no explicit guidance on permissions, but that's not typically required 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?

With schema coverage at 80%, the description adds significant meaning to the critical 'body' parameter: it explains the Comment vs. Message.body exclusivity, the MIME format details, and the replacement behavior. It does not explain the 'confirm' parameter, but that's a standard gating parameter already described in the schema. The description compensates well for the uncovered nuances.

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 (create), resource (draft reply), and scope (sender and all recipients) in the first sentence. It also mentions the two output formats (JSON or MIME), which helps distinguish it from related siblings like create-reply-draft or create-forward-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 strong usage context by explaining the two mutually exclusive ways to specify content (comment vs. message body), the error condition for both, and the MIME base64 requirements. It does not explicitly say 'use this instead of X', but the 'reply-all' framing and the detail on format-specific behavior make the usage context 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?

Annotations indicate destructiveHint: true and readOnlyHint: false, but the description adds valuable behavioral context: it warns that supplying Message.body replaces the whole draft body (quoted history not included), explains the 400 error risk, and notes signatures are added by Outlook client, not Graph. It also describes the draft lifecycle (can update later, send later). This exceeds the annotation minimalism by providing concrete operational constraints and risks.

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 relatively comprehensive with structured bullet points and a prominent tip box. It is front-loaded with the main action and format distinction. While it's a bit long, the length is justified by the complexity of the operation and the multiple format-specific rules. No irrelevant fluff; all content is actionable.

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 the tool is complex (two formats, multiple constraints, RFC details) and has no output schema, the description covers the essential operational details: how to specify the reply content, the mutual exclusivity rule, the MIME encoding requirement, the handling of replyTo, the behavior of the body replacement, and the absence of signature handling. It also mentions the option to send later. This is complete enough for an agent to correctly invoke the tool without needing additional info.

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 80%, and the schema already documents parameters like messageId and confirm. The description adds meaningful semantics for 'body' parameter: explains the comment/body mutual exclusivity, the difference in MIME format (base64 encoded), and the HTML tip. However, it doesn't fully document all parameters, but the schema is largely self-explanatory. A score of 3 is appropriate as the description adds value but doesn't fully compensate for the remaining 20% coverage 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 the tool creates a draft to reply to a message's sender, with formats JSON or MIME. It distinguishes from siblings like create-reply-all-draft and reply-mail-message by focusing on draft creation for the sender. However, it doesn't explicitly name those siblings, so differentiation is mainly implicit.

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

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

Provides detailed guidance on when to use JSON vs MIME, specifically the rule about replyTo vs from recipients, and the constraint that comment and body cannot both be specified. It implies usage for drafting a reply, and mentions 'Alternatively, reply to a message in a single operation' implying a sibling operation exists, but doesn't name it. Clear context but lacks explicit exclusions of 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?

Annotations already signal that this is a mutating/destructive operation (readOnlyHint=false, destructiveHint=true), and the description adds little behavior beyond restating that it creates an event. The tip about not guessing recipient emails is useful workflow advice, but it does not clarify side effects such as invites being sent, permission requirements, or the confirmation 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 compact and front-loaded: the first sentence states the action and target, and the second adds a genuinely important guardrail. Every sentence earns its place, and there is no redundant filler or repeated field-level documentation.

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 create operation, the core target and key user-facing tip are present, and the rich input schema fills in event details. However, the tool is part of a large calendar-related sibling group, and the description does not clarify return values or side effects, and it relies on the agent inferring that the returned object will match the calendar event 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?

With 80% schema description coverage, the schema already documents most parameters well, so the baseline is 3. The description adds some value by clarifying valid calendar targets and calling out the need to use list-users for recipient emails rather than guessing, but it does not systematically improve the agent's understanding of the body parameter's required structure.

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

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

The description clearly identifies the operation as creating a new event in a specific calendar and adds the useful scope that the calendar can be a user calendar or a Microsoft 365 group's default calendar. However, it does not explicitly distinguish itself from the sibling create-calendar-event tool, so an agent could struggle to know why this 'specific' variant exists.

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 functional context: it is used when you want to create an event in a user or M365 group calendar. However, it gives no explicit guidance about when to prefer this tool over create-calendar-event, update-specific-calendar-event, or other sibling calendar tools, and it does not state any exclusions.

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

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

Annotations indicate destructiveHint=true and readOnlyHint=false, consistent with the creation action. The description adds valuable context beyond annotations: it mentions required read permissions, expiration time limits, and validation token requirements, which are not in 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 well-structured with a tip section and front-loaded purpose. While somewhat lengthy, it avoids redundancy and each sentence adds value. The use of bullet-like formatting in the tip aids readability.

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 key aspects: purpose, required fields, permissions, and expiration limits. However, it does not explain the return value (the created subscription object) or error conditions, which would be helpful given the complexity and no 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?

The description adds meaning beyond the schema by summarizing required parameters (changeType, notificationUrl, resource, expirationDateTime, clientState) and providing examples like '/me/mailFolders/inbox/messages'. It also explains optional fields like includeResourceData, which is not covered in 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 subscribes a listener to receive change notifications for a specified resource in Microsoft Graph. It uses specific verbs ('subscribes', 'create') and distinguishes it from siblings like 'get-subscription', 'update-subscription', and 'delete-subscription'.

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 on when to use the tool (to receive change notifications) and includes a tip summarizing required fields. However, it does not explicitly state when not to use it or name alternative tools for similar tasks.

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

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

Annotations indicate destructiveHint: true, but the description does not explain destructive implications (e.g., confirmation requirements). It adds context about the resource association but omits behavioral details like the need for user approval when the confirm gate is enabled.

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 moderately concise, front-loads the purpose, and includes a helpful tip. It could be trimmed slightly, but overall it is efficient and well-structured.

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

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

The description explains the tool's purpose and gives an example, but it does not mention return values (no output schema exists) or clarify parameters like confirm, includeHeaders, or excludeResponse. With 6 parameters and no output schema, more completeness would be beneficial.

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 high (83%), so baseline is 3. The description adds value with an example body structure ('{ webUrl: 'https://...', applicationName: 'Mail', ...}'), clarifying parameter usage beyond schema definitions.

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

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

The description clearly states it creates a linkedResource to associate a task with an item in a partner application, with a concrete example. It does not explicitly distinguish from sibling tools like create-todo-task or list-todo-linked-resources, but the purpose is unambiguous.

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

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

The description provides example use cases (email association, during task creation) but lacks explicit guidance on when not to use this tool or alternatives. The usage context is implied but not systematically covered.

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

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

Annotations already signal readOnlyHint=false and destructiveHint=true, so the description does not need to restate that this mutates data. It adds the scoping context of requiring a specific todoTaskListId, which is useful. However, it does not describe confirmation-gate behavior or response characteristics, though the confirm parameter in the schema covers part of that.

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 compact and front-loaded: the first sentence states the action, and the tip adds the most useful usage details without restating the verbose schema. Every line 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?

For a task-creation tool with a complex nested body schema, the description covers the required call pattern and the main optional fields at the right level of detail. It does not explain return values, but that is not mandatory here. It could be slightly more explicit about confirmation behavior, but the confirm parameter description already handles that.

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 tip distills the large body schema into an actionable template: 'Body: { title: "..." }; optional dueDateTime, reminderDateTime, importance, body (notes), recurrence, categories.' It also tells the agent to source todoTaskListId from list-todo-task-lists, adding meaning beyond the raw schema. The remaining parameters (confirm, includeHeaders, excludeResponse) are left to the schema, but they are not central to calling the tool.

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

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

The description states a specific verb and resource: 'Create a new task object in a specified todoTaskList.' It clearly distinguishes this from sibling tools like update-todo-task, delete-todo-task, and create-todo-task-list, and reinforces the Microsoft To Do context in the tip.

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 clear actionable context: it tells the agent that a todoTaskListId is required and where to get it from (list-todo-task-lists). It does not explicitly call out alternatives or exclusions, but the create-vs-update/delete distinction is clear from the wording.

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

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

The annotations already flag this as a non-read-only, destructive-capable write operation, and the description adds useful behavioral details: the body shape is { displayName: 'My new list' }, the returned fields include id/displayName/isOwner/isShared/wellknownListName, and user-created lists get wellknownListName 'none'. No contradictions with annotations.

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

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

The description is compact and front-loaded with the most useful information. The only mild redundancy is the opening 'Create a new lists object', which echoes the title and is less precise than the tip that follows, but overall 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?

Even without an output schema, the description states what the tool returns and what input is required, which makes it largely complete for a simple creation tool. It does not explain the confirm parameter behavior, but that is fully documented in the input schema itself.

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 75%, so much of the parameter meaning is already documented. The description still adds value by explicitly providing the required body example, { displayName: 'My new list' }, and explaining what the returned wellknownListName will be, which is more practical than the raw schema.

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

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

The description clearly states the action — 'Creates a new Microsoft To Do task list' — and explains what that means via the app-sidebar analogy. It differentiates from create-todo-task by explicitly saying to pair with that tool to populate the list, so an agent can tell them apart.

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 actionable usage context: built-in lists like 'Tasks' and 'Flagged emails' already exist and cannot be re-created, and the tool should be paired with create-todo-task to add tasks. It does not explicitly discuss when to use update-todo-task-list instead, but the create-vs-update distinction is clear enough.

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?

Beyond annotations (readOnlyHint=false, destructiveHint=true), the description discloses that the server does not perform the PUT—the caller must upload bytes to the returned URL. It also notes the body is optional (though this contradicts the schema) and provides a conflictBehavior example, adding meaningful 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 compact and well-structured. It front-loads the purpose, uses a tip to highlight the key use case, and includes only essential details about behavior and body example. No redundant or filler content.

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

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

The description covers the core purpose, use case, and the critical PUT behavior. However, the erroneous 'optional' body representation introduces a reliability gap, and it does not address generic parameters like confirm, includeHeaders, or excludeResponse. These omissions, combined with the contradiction, leave it incomplete for a tool with this many parameters and complex body 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 coverage is high (83%), so the baseline is 3, but the description directly contradicts the schema by stating 'Body (optional)' while the input schema lists body as required. This misleading statement could cause the agent to omit a required parameter. The conflictBehavior example is useful, but the false optionality is a severe flaw.

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 an upload session' and explains it returns a pre-authenticated uploadUrl for large file uploads. It distinguishes itself from the Outlook attachment upload session by noting no size limit and no minimum, making the tool's purpose unambiguous.

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

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

The description explicitly recommends this tool for large file uploads and contrasts it with the Outlook attachment session. It also gives an example path for new files. However, it does not mention when to prefer it over other upload tools like upload-file-content, so the alternatives are only partially covered.

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 a genuinely non-obvious behavior beyond the destructiveHint annotation: 'The event remains in the calendar as declined unless the user deletes it.' This tells the agent that declining does not remove the event, which is exactly the kind of side-effect an agent cannot infer from the schema. It does not contradict annotations and adds real value on top of the destructiveHint flag.

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 compact and front-loaded with the core purpose in the first sentence. The TIP section is somewhat redundant ('Declines a meeting invitation' repeats the opener) and the 'see Propose new meeting times' reference is a dangling link with no URL. Otherwise every sentence earns its place, particularly the persistence note.

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 5-parameter, nested-object tool with no output schema, the description covers the core action, the alternative-time proposal flow, and the post-decline state. It lacks prerequisites (the caller must be the invitee), doesn't mention what the organizer sees (e.g., that a decline response is sent when sendResponse is true), and offers no routing to accept/tentatively-accept siblings. Adequate for the happy path, with clear gaps.

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

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

With 80% schema description coverage, the schema already documents eventId, confirm, includeHeaders, and excludeResponse. The description adds meaning by explaining that ProposedNewTime lets an invitee 'suggest an alternative time' and by giving a body usage example. However, the example uses camelCase keys (sendResponse, comment) while the schema declares PascalCase keys (SendResponse, Comment), which could mislead an agent constructing the body.

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 opens with a specific verb+resource pair: 'Decline invitation to the specified event in a user calendar.' The 'invitation' framing implicitly distinguishes it from siblings like cancel-calendar-event (organizer action) and accept/tentatively-accept-calendar-event. It stops short of naming the sibling it is not, so it misses the top score.

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

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

No explicit when-to-use or when-not-to-use guidance is given relative to accept-calendar-event, tentatively-accept-calendar-event, cancel-calendar-event, or delete-calendar-event, all of which are siblings. The only usage context is the conditional explanation of when proposedNewTime applies, which covers a sub-feature rather than tool selection. The invitee-vs-organizer distinction is left entirely to inference.

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

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

Annotations already indicate destructiveHint: true. The description adds value by specifying that all events within the calendar are deleted and that the action is irreversible. No contradiction with annotations.

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

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

Extremely concise: two sentences plus a tip. The purpose is front-loaded in the first sentence, and the tip adds essential behavioral context without redundancy.

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

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

For a destructive tool with no output schema, the description provides key constraints (non-default calendar only, irreversible) and hints at the confirm parameter (though not detailed). Could mention required permissions, but overall complete for the tool's simplicity.

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

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

Schema coverage is 100%, so the description does not add parameter information beyond the schema. Baseline of 3 is appropriate as the schema already documents all parameters adequately.

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

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

The description clearly states 'Delete a calendar other than the default calendar' and adds a tip that it deletes all events. It distinguishes itself from sibling tools like delete-calendar-event by specifically targeting calendar 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?

Explicitly states that the default calendar cannot be deleted, providing a clear exclusion. The irreversibility warning guides appropriate use. However, no direct comparison to alternative tools like update-calendar or delete-calendar-event is made.

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

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

The description adds behavioral context beyond annotations: it explains that deleting a meeting sends cancellation to attendees and warns about seriesMaster deletion. Annotations already indicate destructiveHint=true, so the description enriches with specific 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 two sentences with a separate tip, all directly relevant. No wasted words, and the critical information is front-loaded.

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

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

Given the moderate complexity and presence of annotations (destructiveHint) and full schema coverage, the description covers key behavioral aspects (cancellation, recursion) adequately. No output schema is needed as return is standard.

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

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

Schema coverage is 100%, so parameters are well-documented. The description adds minimal extra meaning, only hinting that eventId should come from the event's 'id' field. This provides slight additional value, meeting the baseline for high coverage.

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

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

The description uses clear verb 'Removes' and specifies the resource 'event from the containing calendar'. It also distinguishes behavior for meeting cancellation and recurring events, setting it apart from siblings like 'cancel-calendar-event' or 'delete-specific-calendar-event'.

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

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

The description provides a tip about deleting seriesMaster vs single occurrence, which guides usage. However, it does not explicitly state when to use this tool versus alternatives like 'cancel-calendar-event' or 'delete-specific-calendar-event', leaving some ambiguity.

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

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

Annotations already indicate destructiveHint=true, and the description adds valuable context: the default folder cannot be deleted, the folder moves to Deleted Items rather than being permanently removed, and that the id must be obtained via list-contact-folders. No contradiction with annotations.

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

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

The description is extremely concise: two sentences plus a tip, each sentence adds unique value. It is front-loaded with the core purpose and immediately provides 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?

For a destructive tool with no output schema, the description covers key aspects: what it deletes, what cannot be deleted, where items go, and how to get the required id. It is 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?

Schema coverage is 100%, so baseline is 3. The description adds minimal parameter-specific info beyond the schema, only indirectly explaining contactFolderId by referencing list-contact-folders. The schema descriptions are already clear.

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 deletes a contact folder, specifies that the default 'Contacts' folder cannot be deleted, and distinguishes from sibling tools like update-contact-folder and create-contact-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?

The description provides a tip to use list-contact-folders to get the folder id, warns about the default folder not being deletable, and explains that deletion typically lands in Deleted Items. It could be more explicit about when not to use this tool versus alternatives like delete-outlook-contact, but the guidance is 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?

Annotations already declare destructiveHint=true, and the description adds meaningful context by noting that only non-inherited permissions can be deleted and that you should list permissions first. It does not go into full detail about failure modes or response behavior, but with annotation coverage, this is sufficient additional 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 two concise sentences: a clear action statement followed by a helpful tip. It is front-loaded and every sentence carries relevant information without 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?

For a destructive delete operation with no output schema, the description covers the essential prerequisite, the inherited-permission limitation, and the action itself. It could mention what response the user gets or add detail about consequences, but given the moderate complexity and good annotations, it is largely 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 provides 100% coverage with descriptions for all seven parameters, so the description does not need to compensate. The only slight addition is the tip to find the permission ID, which aligns with the permissionId parameter but does not add new semantics 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 uses a specific verb ('Delete') and resource ('drive item permission'), and adds clarifying detail about removing a specific permission from a file or folder. It also distinguishes behavior from sibling tools like list-drive-item-permissions and create-drive-item-share-link by focusing on deletion of an existing permission.

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 tool explicitly advises using list-drive-item-permissions first to obtain the permission ID, which is a clear prerequisite and sequential guideline. It also states a key constraint: only permissions that are not inherited can be deleted, implicitly telling the user when this tool is NOT appropriate (i.e., inherited permissions).

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

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

The description adds meaningful behavioral context beyond the annotations by explaining that deleting a range shifts remaining content and by giving the shift direction options. Annotations already mark this as destructive, and the description aligns with that. It doesn't mention confirmation or side effects, but the destructive hint covers the core safety profile.

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 compact and front-loaded, with the purpose stated first, followed by a concise tip. Every sentence earns its place, and the bullet-point style for the tip improves readability without padding.

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

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

For a destructive operation with no output schema, the description adequately explains the action and key parameter semantics. It doesn't describe return values or prerequisites, but those are less critical for a delete tool, and the schema covers the confirmation parameter. The description is sufficient to guide correct usage.

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?

While the schema provides descriptions for most parameters (88% coverage), the description adds critical meaning for the 'body' parameter by specifying the valid values for 'shift' ('Up' or 'Left') and clarifying their effect. This goes beyond the schema's bare string 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 states a clear verb and resource: 'Delete an Excel range.' It distinguishes from siblings like clear-excel-range by specifying that remaining content is shifted, and provides the shift options ('Up' or 'Left'). This clearly communicates the tool's unique behavior.

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 practical usage guidance via the tip, explaining how to delete cells and shift content, and specifically advises using 'Up' to delete entire rows. While it doesn't explicitly contrast with alternatives or say when not to use it, the context strongly implies the appropriate use case.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, so the destructive nature is covered. The description adds that only a single row is affected and that the index is zero-based, which is useful. However, it does not disclose additional behavioral details such as irreversibility or index shifting after deletion. It does not contradict annotations.

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

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

The description is extremely concise, with only two sentences. The key action and the clarifying tip are both front-loaded and add value without fluff. Every word 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?

The tool is a straightforward destructive row deletion. The description covers what it does and the critical index semantics. The schema covers all parameters, and annotations cover the safety profile. The description could mention consequences like row shifting, but that is not essential given the schema and annotations. Overall, it is adequately complete for this tool's complexity.

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

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

The input schema has 100% coverage with property descriptions, so baseline is 3. The description adds meaningful semantic value by clarifying that the 'index' parameter is zero-based, which is not present in the schema's description ('Value for the index path segment'). This helps the agent correctly interpret and invoke the parameter.

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

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

The description clearly states 'Delete an Excel table row' and further specifies 'Delete a single row from a formal Excel table by zero-based row index.' This is a specific verb+resource description that distinguishes the tool from sibling tools like delete-excel-range or list-excel-table-rows.

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: it is for deleting a single row from a formal Excel table and emphasizes the zero-based index. It does not explicitly exclude alternatives, but the specific wording implies when this tool is appropriate versus related tools. No explicit 'when not to use' guidance, but enough context to guide selection.

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

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

Annotations declare destructiveHint=true, and the description adds contextual detail about the long-term effect on message classification. No contradiction with annotations.

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

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

Extremely concise: two sentences plus a tip, front-loaded with the action. Every sentence adds value without redundancy.

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

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

For a simple delete-by-ID tool with full schema and no output schema, the description covers the purpose, prerequisite, and post-deletion behavior. No gaps.

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

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

Schema coverage is 100%, so parameters are well-documented in the schema. The description adds only implicit reference to the ID, not enhancing parameter meaning beyond 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 'Delete' and the resource 'Focused Inbox override', specifying the effect that future messages revert to default behavior. It distinguishes from sibling tools like list, create, and 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?

Provides a clear prerequisite: 'Use list-focused-inbox-overrides to find the ID first.' Does not explicitly state when not to use or list alternatives, but the nature of a delete tool makes usage straightforward.

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 only repeats the destructive nature already captured by the destructiveHint annotation. It adds no extra context such as confirmation requirements, permanence, or potential side effects. With annotations already disclosing destructiveness, the description contributes no additional behavioral transparency.

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

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

The description is a single short sentence that is direct and free of unnecessary words. It front-loads the core purpose without fluff, which is ideal for conciseness.

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

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

Given the annotations (destructiveHint) and full schema coverage, the description is minimally sufficient. However, it lacks context about the confirmation gate (confirm parameter), return behavior, or prerequisites. This leaves some gaps for an agent, but the tool is simple enough that the description is just 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 100%, so each parameter is already well-described. The description adds no parameter-level meaning. Baseline of 3 is appropriate since the schema carries the full burden.

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

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

The description 'Delete a mail attachment' clearly states the action (delete) and the specific resource (mail attachment), which distinguishes it from sibling tools like delete-mail-message or add-mail-attachment. 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 provides no explicit guidance on when to use this tool versus alternatives. There is no mention of when not to use it or references to sibling tools like list-mail-attachments or delete-mail-message. Usage is only implied by the tool name and description.

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

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

The description adds important behavioral context beyond annotations: irreversible deletion of all contents. It aligns with destructiveHint=true and readOnlyHint=false. 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?

Extremely concise: two sentences and a tip. 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?

The description covers the core function, irreversibility, and how to find folder ID. With no output schema and full input schema coverage, it is largely complete, though parameter details are left to 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 coverage is 100%, so description adds limited value. It mentions specifying folder ID or well-known name, which is helpful but does not elaborate on other parameters like If-Match or includeHeaders.

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 the specified mailFolder' and specifies the resource type, including support for mailSearchFolder. It distinguishes itself from sibling delete tools by focusing on mail 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 tip 'This action is irreversible' and suggestion to use list-mail-folders provide clear guidance on when to use and prerequisites. However, it does not explicitly mention 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 goes beyond annotations by explicitly stating it is a soft delete that moves to Deleted Items. No contradictions with annotations (destructiveHint: true). Adds valuable 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 concise with two sentences plus a tip, no redundant information. Front-loaded with the core action. 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?

For a simple delete operation, with annotations already covering destructive nature, the description adds soft delete nuance, making it complete. No output schema needed for delete.

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

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

Schema coverage is 100% with all parameters described in the input schema. The description does not add extra parameter information, but the baseline for high coverage 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 it deletes an Outlook email message by message ID, with the verb 'delete' matching the tool name. It specifies the action is a soft delete, distinguishing it from permanent deletion and other delete tools among siblings.

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

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

The tip provides explicit guidance on soft delete behavior and how to achieve permanent deletion, giving context on when to use. However, it does not compare with alternative delete methods or specify when not to use.

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

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

Annotations already provide destructiveHint=true, readOnlyHint=false, and openWorldHint=true. The description adds 'permanently' which confirms destruction but does not add other behavioral details like authentication needs, rate limits, or what else might be affected.

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 two sentences and a tip. No wasted 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?

For a delete tool with good annotations and full schema coverage, the description adequately covers the core action. The tip adds useful context. Could mention return value expectations, but not required.

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

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

Schema coverage is 100% with all parameters described. The description does not add additional meaning beyond the schema, so baseline 3 is appropriate.

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

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

The description clearly states the verb 'Delete' and the resource 'messageRule object'. It is specific and distinguishes from sibling tools like create-mail-rule and update-mail-rule, though it does not explicitly differentiate from other delete 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 includes a tip about using the Inbox folder ID for inbox rules, but it does not provide explicit when-to-use vs alternatives or when not to use. No guidance on prerequisites or exclusions.

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