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

The description discloses key behavioral detail beyond the annotations: "Existing attendees are kept; the new addresses are appended." It also explains the meaning of send_notifications. While annotations already indicate idempotency and non-destructiveness, the append behavior is useful extra context that helps an agent predict 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 compact, front-loaded with the core purpose, and then structured as a clean Args list. Each line adds value: behavioral semantics, parameter meanings, defaults, and source hints. There is no filler or repetition.

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

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

Given the tool's moderate complexity (5 params, 2 required) and the availability of an output schema, the description is complete. It covers the operation, side-effect behavior, parameter sourcing, default behavior for notifications, and account selection. No critical information needed to invoke the tool correctly is missing.

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

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

Schema description coverage is 0%, but the description compensates by explaining all five parameters: event_id, attendee_emails, calendar_id, send_notifications, and account. It adds practical guidance such as where to obtain event_id and when to omit account. This fully covers the gap left by the schema.

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

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

The description opens with a specific verb-resource pair: "Invite one or more people to an existing event." This clearly distinguishes it from event creation, movement, deletion, and response tools among the siblings. The title and description align, and the scope is immediately recognizable.

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 clearly states this tool is for adding attendees to an existing event, which implies a use case distinct from create_event or quick_add_event. It also gives practical guidance like using event_id from find_events and omitting account for the default. However, it does not explicitly name alternatives or state 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 provide readOnlyHint=true, idempotentHint=true, and openWorldHint=true, covering the safety profile. The description adds value beyond that by disclosing the aggregation behavior (grouping by day, counting events, summing minutes). 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 compact and well-ordered: purpose sentence, usage sentence, then parameter list. No redundant filler, though the parameter block is somewhat verbose for what the schema already encodes.

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

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

With an output schema present, return-value explanation is unnecessary. The description covers purpose, use case, and all parameters, and the annotations carry the safety profile. Slightly more detail on aggregation granularity could help, but nothing essential is missing.

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

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

Schema description coverage is 0%, so the description fully compensates by documenting all four parameters (time_min, time_max, calendar_id, account) in the Args section, including the note that account defaults to the default and references the 'calendar-mcp accounts' command for discovery.

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 ('Summarise how loaded each day is') with concrete output details (event count, total scheduled minutes). It also differentiates from siblings by noting it answers the busyness question 'without listing every event', which distinguishes it from find_events.

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

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

The description gives a clear trigger condition: 'Use this to answer "how busy is my week" without listing every event.' This communicates the intended use case well, though it stops short of naming explicit alternatives or stating when NOT to use it.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=false, destructiveHint=false, so the mutation behavior is somewhat disclosed. The description adds valuable detail: events are created busy, reminders off, no notifications, last block is trimmed to avoid over-booking, and dry_run avoids writing. This is meaningful behavioral 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?

The description is compact and front-loaded: the main behavior is stated in the first sentence, then algorithms, then side effects, then usage instruction, then parameter explanations. Every sentence adds information and there is no filler.

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 9 parameters, no schema-level descriptions, and an output schema, the description covers the core behavior and parameter semantics well. It doesn't describe the return value structure, but an output schema exists. It also leaves some details unstated, e.g., exact event timing or default calendar resolution, but references `get_preferences` for that. This is sufficient for an agent to select and invoke the tool correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It explains behaviorally what `time_min`, `time_max`, `hours_needed` mean, the meaning of `dry_run`, the effect of `calendar_id` omission, and `check_calendar_ids` as busy-blockers. It doesn't give exact format examples for ISO 8601 (though the schema type is string), but it adds enough meaning for most 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 states a specific verb+resource: it books focus time by turning the best free blocks into calendar events. It also names the sibling tool `find_focus_time` as the source of the blocks, which differentiates it from other calendar creation tools like `create_event` or `quick_add_event`. The behavior is concretely described (longest first, trimming last block).

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 the agent to run it with `dry_run` first when the user has not yet agreed to the times, and explains the relationship to `find_focus_time`. It also clarifies calendar defaults via `get_preferences` and account defaults via 'calendar-mcp accounts'. This gives clear when-to-use guidance and names related tools.

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

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

The annotations already declare readOnlyHint, openWorldHint, and idempotentHint, which cover the primary behavioral traits. The description adds no additional context about side effects or edge cases (e.g., what happens if the event is not found). Given the annotations, the bar is lower, so a baseline score of 3 is appropriate since no extra credit is earned.

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

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

The description is concise and well-structured. It leads with the main purpose in a single sentence, followed by a clear list of arguments. There is no unnecessary information, and the format is easy to parse.

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

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

The tool description, combined with the presence of an output schema, covers the essential aspects: purpose, parameters, and expected output. Minor details like error handling or output format are not explicitly stated, but these are likely covered by the output schema. Overall, it is sufficiently complete for an agent to invoke the tool correctly.

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

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

The description provides meaningful explanations for all four parameters directly in the Args section. Each parameter (event_id, calendar_id, attendee_emails, account) is described with its purpose and source, which compensates for the schema's complete lack of descriptions. This fully clarifies the parameters' roles.

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 function: reporting attendee statuses (accepted, declined, not yet answered). It is specific about the resource (event invitation) and the action (report). However, it does not explicitly differentiate from sibling tools like 'respond_to_event' or 'add_attendee', though 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 no explicit guidance on when to use this tool versus alternatives. It does not mention scenarios such as 'use when you need to check RSVP status' or 'do not use for modifying attendee responses'. The purpose implies a read-only use case, but the lack of explicit when-to-use instructions limits its usefulness.

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 is consistent with annotations: readOnlyHint=false matches the 'Create' action. It adds modest context beyond annotations by specifying the calendar is 'secondary' and 'owned by the user,' but it does not disclose side effects, duplicate-name behavior, or permission requirements. With annotations already covering the read-only/destructive profile, this is adequate but not rich.

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 tight: one front-loaded purpose sentence plus a compact Args section with examples. Every sentence earns its place, and the docstring-style format is scannable. Slight deduction for the cryptic 'calendar-mcp accounts' reference, which assumes prior knowledge of another command.

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 low-complexity 2-parameter create tool with an output schema and annotations present, the description is largely complete: purpose, both parameter semantics, and default behavior are covered. The main gap is the absence of usage-routing guidance relative to siblings, but this is minor given how simple and well-typed the operation is.

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

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

Schema description coverage is 0%, so the description carries the full burden, and it delivers: summary is given a concrete example ('Client work') and account is explained by source ('calendar-mcp accounts') plus default behavior. Both parameters receive meaning the raw schema lacks, making this a strong compensation for the 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 states a specific verb (create), resource (secondary calendar), and ownership (owned by the user), which is meaningfully more specific than the title. It implicitly differentiates from siblings like create_event by targeting a calendar resource rather than an event, though it never names a sibling explicitly.

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?

Usage context is implied via 'secondary calendar' — signaling this is not for the user's primary calendar — but there is no explicit when-to-use/when-not-to-use guidance and no mention of alternatives among the 21 siblings. The account parameter does add operational guidance ('Account name from calendar-mcp accounts; omit for the default').

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, it discloses timezone interpretation ('Without an offset it is read in the calendar's own timezone'), side-effect emailing ('They receive an invitation email unless send_notifications is false'), and account selection. No contradiction with readOnlyHint=false or destructiveHint=false.

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?

Front-loaded with core purpose and sibling routing, followed by a tidy Args block where every line adds non-obvious detail. No filler or repetition of schema-only 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?

For a 9-parameter creation tool with no schema descriptions, it covers all parameters, timezone semantics, notification side effects, and account resolution; an output schema exists to describe return values. The description is fully capable of guiding correct invocation.

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

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

Schema description coverage is 0%, so the description carries the full burden and succeeds: every one of the 9 parameters is explained with real meaning, a required marker on summary, ISO format guidance, and defaults for send_notifications/account. It adds value the bare schema cannot.

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 opens with 'Create an event with explicit start and end times, and optional attendees' — a specific verb, resource, and key behavior. It also names quick_add_event as the alternative for natural-language one-liners, so an agent can distinguish the two creation paths.

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 when to prefer quick_add_event ('For a one-line natural-language description... prefer quick_add_event') and implies this tool is for structured, explicit-time creation. This is direct routing guidance rather than leaving the choice 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?

Beyond annotations (destructiveHint), the description discloses irreversible deletion, confirmation elicitation behavior, and the 'deleted' false outcome when declined. This gives the agent important behavioral expectations not present in the structured 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 tightly written: the irreversible-destruction warning is front-loaded, the elicitation caveat is a single sentence, and the parameter list is scannable. Every sentence adds information.

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

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

Given the annotations, output schema, and sibling list, the description covers purpose, side effects, confirmation behavior, notification defaults, and account selection. No critical information for calling this tool correctly is missing.

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

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

Schema coverage is 0%, but the Args section documents all four parameters with meaning: event_id originates from find_events, calendar_id defaults to primary, send_notifications controls attendee emails and defaults true, and account is sourced from calendar-mcp accounts. This compensates fully for the schema gap.

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

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

The description opens with a specific verb and resource: 'Permanently delete an event.' It clearly distinguishes this from siblings like update_event and move_event, and the permanence warning adds specificity beyond the title.

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 intended context is clear: use this when an event should be permanently removed, with calendar_id and account specifying target. It does not explicitly name alternatives or exclusion conditions, but the resource scope is unambiguous.

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 read-only and idempotent behavior. Description adds further behavioral detail by explaining which event types are excluded and the cross-account nature. 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?

Well-structured with clear sections, but slightly repetitive (the 'which is the point of the tool' phrase appears twice) and some redundancy in parameter explanations. Overall clear and not overly verbose.

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

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

Covers input parameters and behavior thoroughly, but does not describe the output format beyond 'reports two things'. Since no output schema is provided, an agent may need more details on how conflicts and tight events are returned.

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 has zero parameter descriptions, but the Args section in the description provides meaningful explanations for every parameter, including defaults and the purpose of accounts/calendar_ids filtering.

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

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

States a specific verb ('find') and resource ('double-booked events') with scope ('across every signed-in account'). Clearly differentiates from generic search tools like find_events.

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

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

Explains the tool's role and what it reports (conflicts vs. tight), and what events are ignored. Does not explicitly state when to prefer it over alternatives like query_free_busy, 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 provide readOnly, idempotent, and openWorld warnings, and the description adds substantial behavior beyond these: recurrence expansion, inclusive/exclusive window semantics, timezone fallback behavior, and query scope over title, description, location, and attendees. This gives the agent accurate expectations about how results are produced 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 purpose and usage guidance, followed by a compact Args block. Every sentence contributes necessary information; there is no fluff or repetition of schema defaults in ways that waste tokens. The timezone note and inclusive/exclusive distinctions are high-value details.

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

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

Given the tool's moderate complexity — six optional parameters, recurrence expansion, timezone semantics — the description covers everything needed to call it correctly: calendar selection, query fields, narrowing strategy, and account handling. Since an output schema exists, omitting return-value details is acceptable, and no critical behavioral gap remains.

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

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

Schema description coverage is 0%, so the description carries the full burden, and it delivers: each of the six parameters is explained with meaningful details such as 'primary' meaning the user's calendar, time_min inclusivity with ISO 8601 and timezone handling, time_max exclusivity, query fields searched, max_results default, and account selection. This fully compensates for the bare schema.

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

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

The first sentence states a specific verb ('Search'), a clear resource ('a calendar for events'), and a distinctive behavior ('expanding recurring series into instances'). The 'Use this before any tool that needs an event_id' line further anchors its role as the lookup tool among many event-related 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 description explicitly says when to use this tool ('before any tool that needs an event_id') and gives a concrete usage tip ('Narrow the window with time_min/time_max rather than raising max_results'). It does not name specific sibling alternatives or state explicit 'do not use when...' conditions, but the primary selection 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?

The annotations already declare readOnlyHint, openWorldHint, and idempotentHint. The description explicitly states 'Read-only' and explains the algorithm (working hours, lunch, existing items, buffer, longest block first). This adds detail beyond the annotations. However, the reference to `min_focus_block_minutes` (a non-existent parameter) creates a minor inconsistency in the behavioral description, preventing a perfect score.

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

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

The description is well-structured with an introductory sentence, a detailed explanation, a read-only note, and a clean 'Args' section. It is not overly verbose, but the inclusion of the `min_focus_block_minutes` parameter (which is not part of the schema) introduces an unnecessary and confusing element that could have been omitted.

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 provides context about the tool's behavior (longest block first, minimum block length) and the intended use case (finding deep work time). Since an output schema is available, it does not need to fully detail the return structure. The description is mostly complete, but the missing output format details and the `min_focus_block_minutes` inconsistency keep it from being fully 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?

The 'Args' section in the description provides clear, specific explanations for all five parameters: `time_min`, `time_max`, `hours_needed`, `calendar_ids`, and `account`. This goes well beyond the bare schema (which has no descriptions) and fully clarifies the meaning and expected format of each parameter.

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

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

The description clearly states the tool's purpose: it finds uninterrupted time blocks for deep work within a given window, considering working hours, lunch, existing events, and buffer. It also explicitly distinguishes itself as a read-only analysis tool, directing users to `block_focus_time` for actually blocking time. This makes the purpose specific and unambiguous.

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

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

The description gives some usage guidance by noting that it is read-only and that `block_focus_time` is the appropriate tool for actually defending time. However, it does not explicitly compare against other similar tools like `find_events` or `query_free_busy`, nor does it state when to prefer this tool over those. The mention of `min_focus_block_minutes` (which is not a parameter in the schema) adds slight confusion but does not significantly impair usage guidance.

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

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

Beyond the annotations (readOnlyHint=true, idempotentHint=true), the description discloses an important behavioral trait: if never configured, it returns defaults (Mon-Fri 09:00-17:00, no lunch, no buffer) and notes these are only a guess that should be confirmed with the user. This adds significant context an agent needs to interpret results correctly.

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 leads with the operation and resource, then gives when-to-use guidance, then explains the default-value behavior. Every sentence contributes useful, non-redundant information.

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

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

For a parameterless, read-only tool with an output schema and readOnly/idempotent annotations, the description is complete. It tells the agent why and when to call it, what data to expect, and how to handle the unconfigured default case. No critical guidance is missing.

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

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

The tool has zero parameters, so there is no parameter meaning to add. The description still helps by listing the data fields returned (working hours, lunch, buffers, focus), giving the agent a clear sense of what it will receive despite the empty 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 ('Read') and a clear resource ('the user's scheduling preferences'), and enumerates the exact fields returned: working hours, lunch, buffers, and focus. This naturally differentiates it from sibling tools like set_preferences, which writes rather than reads.

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 explicit guidance on when to use the tool: 'Consult this before proposing meeting times or hunting for focus blocks, rather than assuming a nine-to-five.' It does not explicitly name alternatives or when not to use it, but the usage context is clear 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 already declare readOnlyHint and idempotentHint, lowering the burden. The description adds useful behavioral context beyond that: it reveals the existence of a `valid` flag and the auth workflow required for invalid accounts. It also clarifies the default-account concept. No contradictions or misleading statements.

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, front-loaded with the main purpose, and uses three short sentences to cover purpose, cross-tool relevance, and the auth caveat. Every sentence adds necessary information without redundancy or filler.

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 output schema exists and the annotations cover safety and idempotency, the description supplies the missing cross-tool context and validity/auth semantics. Nothing required to call or interpret the tool correctly is missing, making it complete for this straightforward list 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 tool has zero parameters, so the schema already fully covers the input contract. Per the 0-param baseline of 4, no additional parameter documentation is needed, and the description appropriately focuses on output-related context instead.

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 names a specific verb ('List') and a specific resource ('the Google accounts calendar-mcp can use') plus the additional distinction of which is default. This clearly separates it from the event/calendar-oriented sibling tools, none of which deal with account enumeration.

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 statement that every other tool takes an optional `account` argument naming one of these makes the practical use case clear: run this to discover valid account names for subsequent tool calls. It does not explicitly say 'use when you need the default account' or exclude alternatives, but the context is strong and there is no sibling tool serving the same function.

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 declaratively cover read-only and idempotence, so the description does not need to restate those. It adds useful scoping behavior ('user can see', role-based filtering) beyond the schema, but does not discuss additional behavioral concerns like auth or rate limits; this matches the lower bar for annotation-covered tools.

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, front-loaded with the primary purpose, and the parameter list is structured and free of fluff. Each sentence contributes meaningful content, though the text is slightly verbose with two separate ID-related mentions.

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?

A two optional-parameter list for which the description covers purpose, parameter defaults, allowed values, and usage conditions, with an output schema available. No information needed to correctly invoke the tool for the common discovery workflow is missing.

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

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

With 0% schema coverage, the description fully compensates: it explains each parameter's meaning, gives allowed roles for 'min_access_role', describes the 'at least' semantics, and tells how to obtain or omit 'account'. This is enough to call the tool correctly in every scenario.

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?

First sentence uses a specific verb and resource: 'List the calendars the signed-in user can see,' and it specifies key output fields ('IDs and timezones'). The 'Start here...' guidance ties it to other tools and distinguishes it from sibling operations.

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

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

The 'Start here whenever the user mentions a calendar other than their own' provides an explicit when-to-use condition, and the note that returned IDs feed other tools' calendar_id helps coordination. It does not explicitly list when-not-to-use conditions or alternatives, 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?

Beyond the annotations, the description adds meaningful behavioral detail: duration is preserved when new_end is omitted, send_notifications controls attendee emails with default true, and account selection is contextual. It doesn't discuss side effects like whether the original event is removed, but it doesn't contradict 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 well structured and front-loaded: the core purpose comes first, then a compact behavioral example, then a tight Args list. Every sentence earns its place without redundant filler.

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 7-parameter complexity, existing output schema, and annotations, the description is complete enough for an agent to select and invoke the tool correctly. It covers all parameters, key behavior, default notification behavior, and the account selection mechanism.

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

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

With 0% schema description coverage, the description fully compensates by explaining all seven parameters in plain terms, including the 'duration is preserved' nuance and the meaning of destination_calendar_id. This is far more useful than the raw schema titles alone.

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

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

The description clearly states a specific action ('Reschedule an event, and/or move it to a different calendar') tied to a concrete resource. The 'right tool for push my 2pm back an hour' example makes the tool's distinct role easy to grasp relative to broader calendar mutation 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?

It gives explicit usage conditions: supplying only new_start preserves duration, and supplying destination_calendar_id transfers calendars. It also tells users where event_id should come from (find_events). However, it never explicitly names alternatives like update_event or states 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 declare readOnlyHint, openWorldHint, and idempotentHint, so the base safety profile is covered. The description adds valuable behavioral context beyond annotations: it expands RRULEs locally rather than relying on Google-materialized instances, which explains a non-obvious implementation trait that affects results and performance. 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 tight and well-organized: a one-sentence purpose, a differentiating note with a use case, then a clean Args list. No filler or repetition of schema defaults; every sentence adds information needed for correct invocation.

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 five parameters, zero schema descriptions, and an output schema present, the description provides everything an agent needs: purpose, usage guidance, behavioral expectations, and complete parameter semantics. It does not need to describe return values because the output schema exists. Nothing critical is missing.

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

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

Schema description coverage is 0%, so the description carries the full burden of parameter explanation. It does so thoroughly: time_min and time_max are defined as the projection window with ISO 8601 format, calendar_id is the calendar to project, event_query is explained with an example, and account references where to obtain account names and notes the default. This far exceeds the bare schema.

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

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

The description opens with a specific, action-oriented statement: 'Compute future occurrences of recurring events from their recurrence rules.' It clearly identifies the resource (recurring events) and the operation (compute future occurrences), and it explicitly contrasts itself with the sibling find_events, making differentiation immediate.

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 names the alternative tool find_events and explains the precise condition for choosing this tool: it expands RRULEs locally and reaches past the horizon Google materializes instances for. It also gives a concrete use case ('when do my birthdays / standups land next year'), so an agent knows exactly when to invoke this tool over siblings.

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

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

Aligned with readOnlyHint and idempotentHint by describing a read-only retrieval, and adds that it omits event details. 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?

Two concise sentences plus an args list, with no redundant wording or unnecessary detail.

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 the essential aspects given the annotations and output schema; could mention ordering constraints for time_min/time_max, but this is not critical for invocation.

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

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

The description clarifies calendar_ids accepts email addresses and specifies ISO 8601 with UTC offset for time bounds. Response format is not described, but the output schema covers that.

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 the specific verb 'Get' and the resource 'busy intervals for one or more calendars,' and explicitly notes it does not reveal event details, distinguishing it from event-fetching sibling 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?

Provides a clear use case ('check whether someone is free before proposing a time') and notes that it works with email addresses, but does not explicitly contrast with alternatives like find_events or find_focus_time.

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 only declare read-only false and open-world true; the description adds meaningful behavioral context: Google performs the parsing, the calendar's own timezone is used, the parser guesses and may be wrong, attendees/descriptions are unsupported, and the agent should verify the returned start/end. 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?

Three short blocks with no fluff: the core purpose is front-loaded, behavioral caveats follow, and the Args section is clean. 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?

The tool is simple (3 params, 1 required), and the description covers all parameters, timezone behavior, parser limitations, and the need to verify the returned time. With an output schema present, the description is complete enough for an agent to call and interpret this tool correctly.

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

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

Schema description coverage is 0%, so the description carries the full parameter burden. It explains text with concrete examples, calendar_id as the target calendar, and account as a named account from 'calendar-mcp accounts' with an omit-for-default instruction. This adds real meaning beyond the bare schema.

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

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

The first sentence states a specific verb ('Create'), a resource ('an event'), and the distinctive mechanism ('parsed by Google'). It also differentiates from sibling create_event by noting that attendees and descriptions are not handled, so an agent can tell them apart without opening either schema.

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 makes the intended use case explicit: turning plain-English phrases into events, with the caveat that the parser guesses and does not support attendees or descriptions. It also gives account-selection guidance via 'calendar-mcp accounts', though it does not explicitly name the structured 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 cover idempotency and non-destructiveness, and the description adds meaningful behavioral context: the RSVP is scoped to the user, the comment is sent to the organizer, and send_notifications controls whether Google emails the organizer. It effectively discloses side effects 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 compact and front-loaded: it opens with the core action and scope, then provides a tight Args list covering every parameter. No sentence is wasted, and the layout is easy for an agent to parse.

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

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

For a tool with 6 parameters, no schema descriptions, and 2 required parameters, the description is complete. It covers all parameters, defaults, constraints, and behavioral boundaries; the output schema handles return values, so nothing critical is missing.

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

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

Schema description coverage is 0%, so the description carries the full burden and does so excellently. It explains each parameter's meaning, gives the allowed values for response_status, notes defaults, and even points to provenance for event_id and account.

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 ('Set') and a precise resource ('the user's own RSVP on an invitation'), making the action unambiguous. It explicitly scopes behavior to the user's own response and distinguishes itself from any sibling that might modify others' responses.

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 clearly states when the tool is applicable: only on events the user is an attendee of. It also tells the agent what it does not do ('does not change anyone else's response'), which implies when not to use it, though it does not name a specific sibling 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?

The annotations already indicate this is a write operation (readOnlyHint=false), but the description adds valuable behavioral detail: it reads free/busy, creates an event inviting everyone, fails when no slot exists, respects saved preferences, and lets working_hours_start/end only narrow the window. This goes well beyond the structured 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 a one-sentence summary, then a compact behavioral paragraph, then a structured Args list. Every sentence earns its place, and the length is justified by the number of parameters and the nuanced preference behavior.

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

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

Given the tool's complexity (availability search plus booking), the description covers the algorithm, inputs, defaults, failure mode, and edge-case behavior. An output schema exists, so the lack of return-value detail is acceptable, and nothing critical is missing for an agent to invoke the tool correctly.

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

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

Schema description coverage is 0%, so the description carries the full burden of explaining all 13 parameters. It does so thoroughly: ISO 8601 format for time bounds, plain-language meaning for each parameter, defaults, units for duration, and subtle semantics like 'narrow that further; they never widen it' and 'Set false to search the whole window instead.'

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+resource: find a free slot for everyone and book the meeting there. It also clearly explains the algorithm (reads availability, picks earliest gap, creates event) and thereby distinguishes itself from sibling tools like find_focus_time, create_event, and query_free_busy.

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 context for when to use the tool: when you need to find a mutual slot and schedule a meeting in one step. It also provides failure guidance and notes preference options, but it does not explicitly name alternatives or state when-not-to-use this tool versus a specific sibling.

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, the description discloses critical behavior: only passed arguments change, the merged result is validated before writing, rejected changes leave saved preferences untouched, and the tool returns the merged result. This gives an agent an accurate model of side effects and failure 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 substantial but every sentence earns its place. It front-loads merged-result and validation behavior before detailing each parameter, and the examples are directly relevant to avoiding common mistakes.

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 7-parameter tool with no required fields and nuanced update semantics, the description is complete. It covers all parameters, partial-update behavior, validation atomicity, and format expectations. Since an output schema exists, the stated return value is a bonus rather than a requirement.

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

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

Schema description coverage is 0%, so the description must fully document parameters. It does: all seven parameters are explained with meaning, formats, examples, and important caveats such as working_hours being a whole-schedule replacement and clear_lunch being the way to remove a lunch break.

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: 'Update the user's scheduling preferences and save them.' This clearly distinguishes the tool from event-manipulation siblings and from get_preferences, which reads rather than writes.

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 makes the tool's usage context clear: it is for updating saved scheduling preferences, with partial-update semantics that make single corrections easy. It does not explicitly name alternatives or exclusion criteria, but the resource and sibling set make the right invocation context unambiguous.

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 well beyond annotations by disclosing the ranking logic, the buffer penalty behavior, and the conditional side effect: 'Read-only by default' with `apply` performing the actual move. It also distinguishes between suggesting and acting, which is exactly the behavioral nuance an agent needs.

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 organized into a summary, a behavior explanation, a side-effect warning, and a clear Args block. Every sentence contributes meaningful information without repetition or filler, making it easy for an agent to parse quickly.

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

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

For a 7-parameter scheduling tool, the description covers algorithm, ranking criteria, working-hours behavior, side-effect conditions, defaults, and parameter semantics. Since an output schema exists, return values do not need to be described. No critical usage context appears to be missing.

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

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

Schema description coverage is 0%, and the description fully compensates by explaining every parameter's purpose, defaults, and constraints. It even provides cross-tool context like 'from `find_events`' and account sourcing from 'calendar-mcp accounts', which is far more useful than the bare schema.

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

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

The first sentence states a specific verb and resource: 'Propose better times for an existing meeting, ranked, keeping its length.' This clearly separates it from tools like move_event, find_focus_time, or update_event. The description also clarifies that it reads and suggests rather than directly mutates, making the tool's role unmistakable.

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

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

The description explains when to use the tool: for an existing meeting, searching within working hours, and only applying the change after the user agrees. It does not explicitly name sibling alternatives or state when NOT to use it, but it gives strong contextual guidance and warns about setting `apply`.

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 read-only, idempotent, and open-world, and the description adds useful behavior beyond that: declined meetings, 'free' events, and all-day entries are excluded by default, with an 'excluded' field reporting skipped counts. It also discloses that results depend on saved working hours, lunch, buffer, and focus-block preferences, which is meaningful context an agent could not infer from the schema or 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 purpose is front-loaded in the first sentence, followed by concrete example questions, preference context, exclusion behavior, and a complete Args list with no filler. Each sentence contributes necessary information for selecting and invoking the tool correctly.

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 complete for a read-only audit tool with an output schema: it covers the full parameter surface, defaults, exclusions, preference dependencies, and the questions the tool answers. Return-value details are already handled by the output schema, so nothing essential is missing.

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

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

Schema description coverage is 0%, so the description carries the full burden, and it succeeds: every parameter has a plain-language explanation, including ISO 8601 format, the ['primary'] default for calendar_ids, group_by semantics ('day' or ISO 'week'), and the meaning of the two include flags plus account. This is exactly what an agent needs to construct a correct call.

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 and resource ('Report where the user's time went') and spells out the exact questions the tool answers, so an agent immediately knows what it does. It also sets this apart from sibling reporting tools by emphasizing the 'one pass' aggregation of meetings, attendees, and focus time.

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 clearly identifies the use case ('how much of my week is meetings?', 'who am I spending time with?', 'where did my focus time go?') and explains how preferences affect results, referencing get_preferences. However, it does not explicitly mention alternative tools like analyze_busyness, query_free_busy, or find_focus_time or state when not to use this tool, so it falls just short of full guidance.

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

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

Annotations already establish mutability and idempotency, and the description adds meaningful operational behavior beyond them: omitted fields are preserved, updating only start_time alters duration, and send_notifications controls attendee emails with a default of true. It does not contradict the annotations, though it does not discuss how to explicitly clear a field.

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 key behavioral rule and sibling distinction are front-loaded in two tight sentences, followed by a compact Args block that maps directly to the schema. There is no filler or redundancy.

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

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

Given nine parameters and zero schema descriptions, the description is remarkably complete: all args are covered, defaults are stated, the move_event alternative is handled, and the attendee-notification side effect is disclosed. The only minor gap is that clearing a field is not explicitly addressed, and calendar_id's primary default is left to the schema.

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

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

Schema description coverage is 0%, so the description carries the full burden and succeeds. Every one of the nine parameters is explained with field purpose, provenance, format, or default, and it even flags event_id as semantically required despite the schema's default string.

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

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

The description starts with a specific verb and resource: 'Change fields on an existing event' and immediately adds the crucial distinguishing semantic 'Omitted fields are left untouched.' This clearly separates it from create_event, delete_event, and especially move_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 the agent when not to use this tool: to reschedule while keeping duration, use move_event instead, and explains why changing only start_time here leaves the old end time in place. It also instructs where to source event_id and account, giving clear invocation context.

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