Contio MeetingOS

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

Beyond annotations (destructiveHint=true, idempotentHint=true), the description discloses that the action is destructive and irreversible, leads to immediate 401 for integrations, and specifies response codes (404 for unknown ids, 204 No Content on success). 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 concise, consisting of two sentences in the first paragraph for purpose and usage, and a second paragraph for behavioral details. It is front-loaded with the essential action and usage, with 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?

Given the tool's simplicity (one parameter, no output schema, annotations present), the description covers purpose, usage, behavioral details, parameter semantics, and error codes comprehensively. It is complete for understanding and invoking 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 schema covers the 'id' parameter with a basic description. The description adds value by explaining that the id comes from v1ListUserTokens, guiding the user on how to obtain it. This surpasses the schema-only baseline of 3.

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?

Tautological: description restates name/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 description directly tells when to use the tool ('Use this when the user wants to invalidate a token') and how to prepare ('use listUserTokens to find the id'), providing clear guidance on usage and 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 declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safe, read-only behavior is fully captured. The description adds value by stating the access control rule (only returned if caller is assignee or participant) and that inaccessible IDs return 404, which is not in annotations. No further behavior (e.g., rate limits, partial results) is needed, making this score appropriate.

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 short paragraphs, front-loaded with the purpose. Every sentence earns its place: the first sentence states the purpose, the second provides usage guidelines with sibling reference, the third explains behavior (access control), and the fourth lists key fields to read. 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?

The tool has one simple parameter, high schema coverage, a good annotation set, and an output schema. The description covers purpose, usage guidelines, access control, and key return fields. Given the low complexity and full support from structured fields, nothing 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 100%, so the schema already documents the single `id` parameter as 'Action Item ID'. The description adds nuance by specifying that `id` is expected in `{id}` placeholder notation and that it should be a specific action item ID, but since schema coverage is complete, little extra is needed. Baseline 3 is correct.

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?

Tautological: description restates name/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 description explicitly says 'Use this when the user asks about a specific action item; use listActionItems to see all tasks.' This provides a sharp when-to-use/when-not-to-use rule and names the alternative sibling. It also specifies that inaccessible IDs return 404, guiding error handling.

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, idempotentHint, destructiveHint. Description adds value by disclosing that items outside the caller's workspace and backlog items are hidden as 404, and by naming specific returned fields (status, title, time_allocation_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?

Two concise sentences, front-loaded with purpose, no redundant words. Every sentence contributes meaning: purpose, sibling guidance, behavioral detail, and parameter usage.

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?

Tool is simple (1 param, annotated, has output schema). Description covers purpose, when to use, special behaviors, and which fields are readable. Output schema already handles return value documentation, so no additional explanation needed.

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

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

Schema coverage is 100% (single id parameter described in schema). The description mentions fetching by `{id}` but does not add semantic detail beyond the schema (e.g., format, constraints, or examples). Baseline 3 applies as schema already fully describes 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?

Tautological: description restates name/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?

Provides explicit when-to-use guidance ('when user asks about one agenda item') and when-not-to ('use listAgendaItems for full agenda'), plus special behavioral context (items outside workspace or backlog return 404).

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, destructiveHint=false, so the safety profile is clear. The description adds valuable behavioral context: the id parameter is specifically the 'backlog handle, not agenda_item_id', items assigned or deleted return 404, and 'talking_points contains only the caller's private note'. There is 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 two concise paragraphs. The first sentence declares purpose and usage. The second paragraph provides key behavioral detail in a compact format. Every sentence earns its place with 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 the simple tool (1 parameter, no enums, annotations present, output schema present), the description fully covers the edge cases (404 for assigned/deleted items, pointer to history, private nature of talking_points). The output schema exists so the agent can infer return structure. No gaps remain for this complexity level.

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 a single required 'id' parameter described as 'Backlog item ID'. The description adds significant semantic value beyond the schema: it clarifies that the id is the 'backlog handle, not agenda_item_id' and that items not in active unscheduled status return 404. This helps the agent avoid passing the wrong identifier.

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?

Tautological: description restates name/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 description explicitly states when to use: 'when the user asks about a specific backlog item', and when not to use: 'items that are already assigned or deleted return 404; find them in v1ListBacklogItemHistory'. It also names exact alternatives: 'use listBacklogItems to see all active backlog and listBacklogItemHistory for used or discarded ones'. This provides full 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?

Annotations already provide readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the description doesn't need to cover safety. It adds value by stating the required scope ('meetings:read') and that it returns 404 for unknown or non-owned events, which is useful but not extensive 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 two tightly written sentences, front-loaded with the core purpose and usage guidance, followed by a sentence adding technical detail (scoping, error behavior). 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 the high schema coverage (100%), clear annotations, and a single required parameter, the description is nearly complete. It covers purpose, usage, prerequisites (id from list call), auth scope, and error condition. Could potentially add how to retrieve the id if not already discovered, but that is tangential. The output schema exists, so return value details are not needed in the description.

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

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

The schema has 100% coverage with a single parameter 'id' described as 'Calendar Event ID'. The description adds that the id comes from v1ListCalendarEvents, which is helpful context, but since the schema already describes the parameter, the baseline is 3.

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?

Tautological: description restates name/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?

Explicitly tells when to use this tool ('when the user asks about a specific event') and when to use an alternative ('use listCalendarEvents to see events in a time range'). Also clarifies it depends on first discovering the event via the list call, providing clear 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 declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is well-covered. The description adds that authentication is required but no resource scope, and that repeated calls do not change state. This aligns with annotations but doesn't reveal additional behavioral nuance beyond what annotations already indicate.

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 front-loaded with the purpose and usage. The only redundancy is that the title and description repeat the same information. The text could be slightly shortened without losing meaning, but it remains efficient.

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 has zero parameters, rich annotations, and an output schema that presumably details the return structure, the description completely covers the necessary context. It explains the purpose, when to use it, and the authentication model. There is no 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 zero parameters and schema description coverage is 100%, so there is nothing to add. The description does mention what the tool returns (user id, email, workspace id, etc.), which adds some value but is not about parameters. Baseline 3 is appropriate since the schema requires no compensation.

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

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

Tautological: description restates name/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 description explicitly states when to use it ('when the user asks about who they are, their plan, or their workspace') and suggests using it before operations that require identifiers like user id or workspace id. It does not specify when not to use it, but the explicit usage context is sufficient.

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, idempotentHint, destructiveHint), the description adds critical behavioral details: summary_notes presence and tier-dependent truncation, redirect_to_meeting_id meaning, and 404 response. 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 concise (four sentences), front-loaded with purpose and usage guidance, and contains no redundant or extraneous information. Every sentence adds value.

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

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

Given the tool's simplicity (single parameter, output schema present, rich annotations), the description covers purpose, usage, error handling, and special behaviors (summary, redirect). It is fully adequate 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?

The input schema covers the single parameter 'id' with 'Meeting ID' (100% coverage). The description does not add new semantic meaning to the parameter beyond stating it fetches by that id, but it does explain error behavior for invalid IDs. 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?

Tautological: description restates name/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 description provides explicit when-to-use guidance ('when the user asks about a specific meeting by id') and names alternative tools for different scenarios. It also mentions that unknown or inaccessible ids return 404, aiding error handling.

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=true, idempotentHint=true, destructiveHint=false. The description adds significant behavioral context: 'Metadata only: no storage location is ever exposed' and 'fetch bytes with v1DownloadMeetingAttachment' clarifies what the tool does not do. It also explains the 404 response for mismatched or unauthorized attachments, which is helpful for error handling. 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 concise at 5 sentences, each serving a distinct purpose: purpose+usage, return value+scope, metadata-only+download redirect, error condition. No redundant or filler sentences. Information is front-loaded with the most critical usage guidance.

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

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

Given the tool has 2 simple parameters, 100% schema coverage, annotations, and an output schema (not shown but present), the description covers all needed aspects: what it returns (metadata only, no storage location), how to get the attachment_id, required scope, error behavior, and sibling differentiation. It is fully sufficient for correct agent 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?

Input schema has 2 parameters with descriptions (100% coverage). The description adds value beyond schema: it explains that the attachment_id comes from 'v1ListMeetingAttachments' and that the tool is keyed by both meeting id and attachment_id. This contextual information helps the agent understand how to obtain the correct attachment_id and the relationship between the two 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?

Tautological: description restates name/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 description provides explicit guidance: 'Use this when the user asks about a specific file; for AI context docs use getMeetingContext and for the actual bytes use manageMeetingContent download.' It also states the required scope ('meetings:read'), and explains the error condition (404 for wrong or unauthorized access), which helps the agent decide when to invoke 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, idempotentHint, and destructiveHint false, so the agent knows this is a safe, read-only, idempotent operation. The description adds value by noting that unknown or inaccessible IDs return 404, but doesn't elaborate beyond that (e.g., response format, pagination). With annotations covering the safety profile, this is adequate but not exceptional.

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 succinct paragraphs with no wasted words. It front-loads the core purpose and alternatives, then adds behavioral notes. Every sentence adds value.

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

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

Given the tool has only 2 parameters with 100% schema coverage, rich annotations, an output schema, and no nested objects, the description is complete. It covers purpose, when not to use, alternatives, and error behavior. No gaps remain.

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

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

Schema coverage is 100%, meaning the input schema already documents both parameters (id and context_id) with descriptions. The description restates that the tool uses meeting `{id}` and `{context_id}`, but adds no additional details beyond what the schema provides (e.g., format, constraints, or examples). 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?

Tautological: description restates name/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 description explicitly tells when to use this tool (when user asks about a specific context doc) and when not to (for raw files use v1GetMeetingAttachment; for text use manageMeetingContent download). It also mentions behavior for unknown or inaccessible IDs (return 404), providing clear 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?

Adds significant behavioral details beyond annotations: returns 402 on lower tiers, response is binary SRT content not JSON, format only supports 'srt'. Annotations already indicate read-only and idempotent, and description complements without contradiction.

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 reasonably concise but has redundancy: the first sentence repeats the title. Two sentences packed with information, but could be tightened by removing the title 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?

For a tool with 2 parameters and no output schema, the description fully covers behavior: what it does, constraints (Elite plan, 402 error), output format (binary SRT), and parameter defaults. No gaps identified.

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?

Input schema has 100% coverage with descriptions. Description adds value by stating format defaults to 'srt' and that it's the only supported value, which is not in the schema. This clarifies parameter behavior 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?

Tautological: description restates name/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?

Explicitly lists when to use: 'when the user asks for the transcript, meeting transcript, SRT/captions, or recording transcript'. Also notes Elite plan requirement. Does not explicitly exclude alternatives, but context is clear enough given sibling tool names.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description does not need to repeat those. The description adds valuable behavioral context beyond annotations: it specifies that only items assigned to the caller are returned ('Items assigned to other members are not returned'), and it clarifies pagination limits ('1–100') and filtering options. 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 extremely concise—only three sentences, all front-loaded with the core purpose. No wasted words; every sentence adds essential information (tool scope, sibling differentiation, filtering, pagination, and typical usage pattern).

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 (so return values need no extra explanation), the description covers all necessary context: the tool's scope (caller only), filtering, pagination, relationship to sibling tools, and a concrete use case (discovering IDs for update/delete tools). No gaps remain for an AI agent to correctly select and invoke this tool.

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

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

Schema description coverage is 100%, but the description adds meaning by explaining the purpose of each parameter group: 'Filter by meeting_id and/or status; paginate with limit and offset (1–100).' It also narrows the schema's broad integer range for limit to a practical '1–100' range, which the schema's description alone ('Maximum items per page (1-100)') already states, but the description reinforces it in 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?

Tautological: description restates name/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 description explicitly tells when to use this tool (to see caller-assigned action items) and when to use the sibling getActionItem (for single task details). It also notes that items assigned to other members are not returned, guiding the agent to avoid inappropriate usage. Additionally, it states that this tool is meant to discover IDs for v1UpdateActionItem and v1DeleteActionItem.

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=true and destructiveHint=false, so the description only needs to add context beyond these. It adds that only caller-accessible items are listed, and notes that the tool supports filtering by meeting_id and pagination with limit/offset. However, it does not specify whether the output includes the sequence ordering or the exact structure of a returned item (though output schema exists). A minor gap is that the description makes it sound like this is solely for reading, but doesn't mention if any side effects (like marking items as viewed) occur—but annotations cover this. Score 4 because it adds useful 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 two paragraphs, with the first giving the core purpose and the second providing additional usage context. It is fairly concise, but the second paragraph could be slightly tightened (e.g., combining 'Filter by meeting_id' with the pagination note). However, no sentence is wasted, and the key information is front-loaded.

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

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

Given that an output schema exists (so return value details are not needed), the description is quite complete. It covers purpose, usage alternatives, filtering, pagination, and operational use cases (reading sequence, discovering IDs). A minor gap is that it doesn't mention how the output relates to the sequence ordering, but that is a very specific detail that may be better suited in the output schema.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds context for meeting_id ('Filter by meeting_id') and pagination ('paginate with limit and offset (1–100)') but this largely echoes the schema descriptions. It does not add new semantic meaning beyond what the schema provides, so a score of 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?

Tautological: description restates name/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 description provides explicit usage guidance: it tells when to use this tool (to see the full agenda, to read the current sequence ordering before inserting/reordering, to discover IDs for updates/deletes) and when to use the alternative ('getAgendaItem'). This covers both situational context and exclusion criteria.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the tool is safe and idempotent. The description adds valuable behavioral context: items listed are 'terminal — they cannot be updated or reassigned', and an ID appears here or in v1ListBacklogItems, never both. This goes beyond what annotations provide, earning a 4.

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 paragraphs and front-loads the purpose in the first sentence. Every sentence adds value: sibling tool references, state explanation, and pagation constraints. It is not verbose, though it could be slightly shortened by removing redundant pagination detail that already exists in 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?

Given the output schema exists (so return values need not be described), annotations cover idempotency and safety, and schema covers all 3 parameters, the description completes the picture well. It explains the tool's scope (history of assigned/deleted items), terminal nature, and mutual exclusivity with listBacklogItems. Only minor missing context: it doesn't specify the default sort order 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 100%, so the schema already documents all three parameters. The description mentions pagination with `limit` and `offset` (1–100), which aligns with the schema descriptions. However, it does not add semantic meaning beyond what the schema provides for `sort_order`. A baseline of 3 is appropriate since the schema does the heavy lifting.

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?

Tautological: description restates name/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 description provides explicit when-to-use guidance: 'Use this to see the backlog history; use listBacklogItems for active unscheduled items and getBacklogItem for one active item.' It also explains that items here are terminal and cannot be updated or reassigned, which preempts misuse. The pagination constraints (limit 1–100) are clearly stated.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so the tool is safe. The description adds valuable context: it lists only the caller's items, excludes assigned/deleted, paginates with limit/offset (1-100), and notes that 'id' is the backlog handle, not agenda_item_id. 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?

Two concise paragraphs: the first front-loads the purpose and sibling alternatives, the second adds details on scope, exclusions, pagination, and id field. Every sentence adds value, no redundancy.

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

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

Given the schema fully describes all parameters, annotations are present, and an output schema exists, the description covers usage, exclusions, pagination, and id semantics. Minor gap: sort_order options are not detailed beyond what the schema says, but overall it is sufficiently complete.

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

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

Schema coverage is 100%, so baseline is 3. The description mentions pagination with limit/offset (1-100) and the id field nuance, but does not add meaning for sort_order beyond what the schema already provides ('Sort direction on the time the item reached the backlog'). Minimal 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?

Tautological: description restates name/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?

Explicit when-to-use guidance is provided: 'Use this to view active backlog items; use getBacklogItem for one item's details and listBacklogItemHistory for used or discarded ones.' It also clarifies what is excluded ('Items assigned or deleted are excluded') and names the alternative tool for those.

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, idempotentHint, and destructiveHint. The description adds valuable context: that events belong to the caller, required date range format (ISO-8601), pagination limits (1–100), and interpretation of empty results. 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 concise, using only 5 sentences. It is front-loaded with the purpose and sibling distinction, then provides essential operational details. 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?

Given the tool's complexity (5 parameters, 2 required, output schema present), the description covers purpose, when to use, parameter roles, pagination, ordering, and result interpretation. It could mention authentication scoping (assumed from 'caller'), but overall it is complete for an AI 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% with detailed descriptions for all 5 parameters. The description reiterates the required parameters and format, and adds a pagination range (1–100) that partially overlaps the schema's 'max 100' and default. The added value beyond the schema is modest, so 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?

Tautological: description restates name/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 description explicitly tells when to use this tool ('to see multiple events') and when to use the sibling 'getCalendarEvent' ('for the details of a single event'). It also explains that an empty result usually means no events. However, it could be stronger by explicitly stating not to use this for modifications (given the presence of 'manageCalendarEvents' in 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?

Annotations already declare readOnlyHint and idempotentHint true, and destructiveHint false. The description adds valuable behavioral context: files are stored as-is (not normalized), returns 404 for unknown/inaccessible meetings, and pagination behavior with limit/offset. 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 a compact paragraph without extraneous words. It front-loads the main action, then immediately gives usage alternatives, then pagination details, then error case. 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?

With an output schema present, the description does not need to detail return values. It covers error behavior (404), pagination defaults, and the nature of attachments (raw, not AI-visible). Given the tool's simplicity and the richness of schema/annotations, this is fully complete.

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

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

Schema coverage is 100% with descriptions for all three parameters. The description adds the default value for limit (25), which is not in the schema. This enhances the agent's understanding of typical usage beyond what the schema alone provides.

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?

Tautological: description restates name/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 description explicitly states when to use this tool ('to see uploaded files') and provides clear alternatives: use manageMeetingContent for bytes retrieval and deletion, and v1ListMeetingContext for AI context documents. This gives the agent precise decision logic.

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=true, so the description's mention of 'searching' is consistent. It adds value by stating that registered-user status is not exposed, a behavior not captured by annotations. No other behavioral gaps are noted, though the pagination behavior could be more explicit. However, with annotations covering safety, this is strong.

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 short paragraphs, starting with the core purpose. Every sentence adds new information: purpose, usage scenario, parameters, follow-up action, and a limitation. No filler or repetition, making it efficient 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?

The tool has 4 parameters (1 required), an output schema, and no nested objects. The description covers the search behavior, how to use results, and a key limitation. Pagination details are in the schema, and the output schema handles return values. The context is fully sufficient for correct invocation.

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

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

Schema coverage is 100% (all 4 parameters documented), but the description adds crucial context beyond the schema: it tells the agent to use the returned email as guest_email in another tool, and clarifies that q is a substring search. This goes beyond baseline schema documentation.

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?

Tautological: description restates name/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 description provides explicit when-to-use guidance: 'when the user gives only a name or initials and you need the matching email/address'. It also names the alternative tool for the next step ('Use manageMeetingParticipants add to actually add them to a meeting') and notes a limitation ('Does not expose registered-user status'). This meets the highest criteria.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description doesn't contradict them. It adds behavioral context beyond annotations: pagination bounds (1–100), the 404 error for unknown/out-of-workspace meetings, and that it returns only text-biased AI-visible documents. Minor deduction: no mention of response structure or whether the list is ordered, though output schema exists.

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 action, uses a second paragraph for supplemental details (alternatives, pagination, errors). Slight redundancy between paragraphs (both mention alternatives and raw file listing). Could be tightened by removing one sentence without losing meaning. Still efficient overall.

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 3 parameters, 100% schema coverage, a read-only annotation, and an output schema, the description is nearly complete. It covers purpose, alternatives, pagination, and errors. Minor gap: doesn't clarify that the output is likely a list summary (metadata, not content), but the output schema exists and the tool name implies context metadata. For a discovery tool, it's sufficient.

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

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

Schema description coverage is 100%, so the schema already documents id, limit, and offset with types and descriptions. The description adds value by stating that limit/offset are 'clamped 1–100' and that 404 occurs for invalid meetings, which goes beyond schema. Baseline 3, plus 1 for additional 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?

Tautological: description restates name/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?

It explicitly tells when to use this tool (as discovery before getMeetingContext or download), when not to (for raw files, use listMeetingAttachments), and provides pagination details with limit/offset clamping. The alternatives are named: getMeetingContext and manageMeetingContent download.

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, idempotentHint, and destructiveHint, so the description adds value beyond them. It discloses that the tool returns 404 for unknown/inaccessible meetings, explains pagination with limit and offset, and notes that the user id in each item is the value passed to v1RemoveMeetingParticipant. No contradictions.

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

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

The description is concise and front-loaded: the first sentence states the purpose and usage guidance. The second paragraph adds pagination, error handling, and cross-reference. Every sentence is necessary and informative.

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

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

For a read-only list tool with good annotations, complete schema, and an output schema, the description fully covers purpose, usage, pagination, error handling, and cross-reference to a related tool. No gaps are 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 coverage is 100%, so baseline is 3. The description adds meaning by specifying the pagination range (1-100) for limit, reinforcing the default behavior, and linking the output user id to the remove endpoint. This goes beyond the schema's parameter 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?

Tautological: description restates name/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?

Explicit usage guidance is provided: 'Use this to view the participant list; use manageMeetingParticipants to add, remove, or change roles.' It also mentions pagination and how to use the user id from the output to remove participants, giving clear context for when and how to use the 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?

The description adds value beyond the annotations (readOnlyHint, idempotentHint, destructiveHint) by noting pagination behavior with limit/offset and the response total, as well as that items are summary views without summary_notes (use v1GetMeeting for details). 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 concise, using three short sentences that front-load the purpose and sibling guidance, then add pagination and detail behavior efficiently. No wasted text.

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 is a simple paginated listing with two well-documented parameters and an output schema (which handles return value documentation), the description covers purpose, usage guidance, pagination, and data limitations completely. No gaps remain.

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

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

Schema coverage is 100%, so baseline is 3. The description restates the pagination parameters (limit, offset) in prose and adds context about the response total, but doesn't add new semantic details beyond the schema's description of defaults and ranges.

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?

Tautological: description restates name/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 description explicitly tells when to use this tool (to see all meetings) and when not to (prefer searchMeetings for keyword/date/participant/status, listUpcomingMeetings for soonest future ones), naming the sibling alternatives directly.

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 (readOnlyHint, idempotentHint, destructiveHint) already declare safe read behavior. Description adds valuable context: templates are scoped to caller (system, vertical, workspace, personal), pagination details, and 'No paid-tier gating'. This goes beyond annotations without contradicting them. One point off for not mentioning any rate limits or response structure beyond the output 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?

Two compact sentences that front-load the primary purpose. Every sentence adds value: browsing, usage chaining, template scope, pagination, and free tier. No redundant 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 simplicity (no required params, pagination, output schema present), the description is complete. It covers when to use, what templates are included, how to paginate, and tier availability. The output schema exists so return values need not be described.

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 covers both parameters with descriptions (100% coverage). Description adds the default value for limit (20) and confirms pagination semantics. This is helpful beyond the schema, but offset is still minimally described. Baseline 3, plus 1 for adding default and range.

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?

Tautological: description restates name/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?

Explicitly states when to use: 'Use this to see available templates' and 'Call this to get a template_id for v1CreateMeeting'. It also provides chaining guidance to manageMeetings. No alternative tool for listing templates exists among siblings, so exclusion is implicit but 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 readOnlyHint, idempotentHint, and destructiveHint, so safety traits are covered. The description adds behavioral context beyond annotations: pagination behavior (limit/offset, response 'total' signals stop), sorting (soonest first), summary views, and a pointer to v1GetMeeting for full details. This is valuable context for an AI agent.

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

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

The description is extremely concise and well-structured: a single front-loaded sentence for purpose and usage alternatives, followed by two additional sentences covering pagination and response detail level. Every sentence earns its place with no waste.

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

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

Despite having an output schema (which explains return values), the description covers all necessary aspects: purpose, sibling differentiation, pagination, sort order, and what level of detail the returned items provide. It is complete for a read-only list tool with well-annotated safety profile.

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 baseline is 3. The description mentions pagination with `limit` and `offset` and the meaning of `total`, which reinforces the schema's parameter descriptions but does not add new semantic detail beyond what is already in the schema. It adds no additional constraints or context for the agent.

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?

Tautological: description restates name/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 description provides explicit guidance on when to use this tool ('when the user asks what is coming up') and names two alternatives (listMeetings and searchMeetings) along with their distinct use cases. However, it does not cover when not to use it or any prerequisites.

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

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

Beyond annotations (readOnly, idempotent, non-destructive), description adds that only non-revoked tokens are returned, full secret never returned, and clarifies token id purpose. This provides 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?

Mostly concise with front-loaded purpose. However, the title and description first sentence repeat nearly verbatim, causing minor redundancy. Still efficient overall.

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 output schema exists, description covers all behavioral aspects: pagination, security (masked prefix, no full secret), caller scope, and link to deletion tool. 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?

Schema has only limit/offset with basic descriptions (100% coverage). Description adds meaning: pagination behavior, valid range 1-100, and clarifies that token id is for deletion, not the secret. Adds significant value 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?

Tautological: description restates name/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?

Provides explicit guidance: 'Use this to see tokens; use deleteUserToken to revoke one.' Also notes no special scope/role required, making usage conditions 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 description adds rich behavioral details beyond annotations: for create, it mentions idempotency via Idempotency-Key and risk of duplicates on blind retries; for delete, it explains soft-delete behavior and 404 on second attempt; for update, it notes partial update, state machine, and lack of idempotency. This context is critical for safe invocation.

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 clear sections for each action and front-loaded purpose. It is somewhat verbose but remains organized and easy to navigate. Minor trimming could improve conciseness without losing 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?

Despite having no output schema, the description covers all three actions, required parameters, error responses (404, 204, 201), idempotency behavior, and status state machine. It provides sufficient context for an agent to call the tool correctly in all 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?

With 100% schema coverage, baseline is 3. The description adds meaning by explaining conditional requirements (e.g., meeting_id and title required for create), the role of the action parameter, and the idempotency key's effect. It does not repeat all parameters but provides actionable 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?

Tautological: description restates name/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 description provides clear when-to-use guidance for each action (e.g., 'Use this when the user wants to track work that came out of a meeting') and references alternatives. However, it does not explicitly list exclusions beyond the initial sibling differentiation.

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 provide idempotentHint=true and destructiveHint=false, but the description adds rich behavioral context beyond these: idempotency behavior with Idempotency-Key, return codes (200, 201, 404, 409, 400, 403), no-op behavior for unlink, auth requirements per action (calendar:write, meetings:write), and edge cases like already linked or unknown events. 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 a summary, then action parameter explanation, then three sub-sections for each action. It is front-loaded with the main purpose. While it is somewhat verbose with repeated 'Use this when...' phrases, each sentence earns its place by adding essential context. The structure makes it easy for an agent to parse the relevant action.

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 4 parameters, no output schema, and no nested objects, the description covers all actions, auth requirements, error codes, idempotency, and edge cases. It even references a sibling tool (v1UnlinkCalendarEvent). However, it lacks a description of the response body (e.g., what the created/linked meeting object looks like), which would be helpful for an agent parsing the result. Still, the status codes and idempotency details provide sufficient operational completeness.

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

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

Schema coverage is 100% (all parameters documented), but the description adds significant meaning beyond schema: it explains the action enum values in context, clarifies which parameters are relevant for each action (e.g., id for createFromEvent, id and calendar_event_id for link), and details the Idempotency-Key behavior. This transforms the schema from a list of fields into a coherent usage guide.

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?

Tautological: description restates name/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 description provides explicit usage guidance for each action: 'Use this when the user wants to import an existing calendar event' for createFromEvent, 'when the user wants to sync a meeting to a calendar' for link, and 'when the user wants to stop syncing a meeting to a calendar' for unlink. It also tells when NOT to use this tool (use dedicated tools for content/participants), giving clear 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 indicate destructive (destructiveHint=true) and non-idempotent (idempotentHint=false). The description adds rich behavioral context: required scope (meetings:write), irreversibility of delete, error codes (403, 404, 400, 413), size caps (50MB for attachments, 4.5MB for context), idempotency details for delete (404 on repeat), and response format for download. 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 well-structured: a high-level summary followed by a clear breakdown of all six contentType-action pairs. Each variant includes a usage hint and technical details. Despite length, every sentence adds value, and the structure makes it easy to scan. 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 the tool's complexity (13 parameters, 6 variants, no output schema), the description is exceptionally complete. It covers all combinations, error responses, size limits, idempotency, auth scope, and response format for download. The only minor gap is no explicit confirmation of delete response (204 implied), but it's still sufficient.

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

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

Schema coverage is 100% (all parameters have descriptions). The description adds significant meaning: which parameters are required per combination, valid values (e.g., kind only accepts 'file', source_format required for context upload), and constraints (e.g., file must be base64). This far exceeds the schema alone.

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

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

Tautological: description restates name/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 description provides explicit guidance on when to use each contentType-action combination, including alternative tools (e.g., 'for raw files use the attachment download instead'). It covers prerequisites, error scenarios, and trade-offs between attachment and context, giving clear when-to-use and when-not-to-use instructions.

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 considerably enriches the annotations. It details which operations are effectively idempotent (delete), which are not (update), required scopes (meetings:write), soft-delete behavior with historical tracking, and what DEFERRED does (skips, does not move to backlog). This goes well beyond the destructiveHint and idempotentHint flags, providing concrete behavioral detail.

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 highly structured with a general overview, variant selector explanation, and seven distinct operation blocks. Every sentence adds value. Front-loading is good. The length is justified by the combinatorial complexity, but a slightly more concise generalization could reduce verbosity while maintaining 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 is self-contained for an AI agent. It covers all seven operation combinations, required parameters, expected HTTP status codes, return bodies, idempotency details, scope requirements, and cross-links to related tools (v1ListAgendaItems, v1AssignBacklogItem). With no output schema, the description sufficiently explains return values and error cases.

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

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

Despite 100% schema coverage, the description adds critical semantic context: which parameters are required per operation, valid item_type values, the role of backlog/action as selectors, and cross-references to other tools for IDs. It explains constraints like presenters max 50 and Idempotency-Key usage beyond the 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?

Tautological: description restates name/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 description provides comprehensive when-to-use guidance for each backlog/action combination, clearly delineates from alternatives ('those are handled by separate tools'), and includes error handling directives (e.g., 409 means meeting ended, do not retry; 404 meaning unknown id). It also advises on idempotency retries and required scopes. No gaps.

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 destructiveHint=true and idempotentHint=true. The description reinforces these by explaining idempotency for add (using Idempotency-Key) and for remove/updateRole (safe to retry, converge on requested state). It also adds specific behaviors like no-op for duplicate adds, required scope 'meetings:write', and response codes (204, 404). This goes 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 well-structured with clear sections for each action (add, remove, updateRole) and is front-loaded with the overall purpose and sibling differentiation. It is somewhat lengthy, but every section provides necessary operational details, making the length justified.

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 6 parameters, 100% schema coverage, no output schema, and moderate complexity with nested objects for participants, the description is sufficiently complete. It covers per-action use cases, required parameters, idempotency, error handling, and prerequisites. It could mention the return type (aside from the 204 success code) but overall is robust.

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 covers 100% with descriptions for all parameters. The description maps actions to required fields (e.g., action=add requires `id` and `participants` array) and clarifies usage nuances like mutual exclusivity of user_id and guest_email (though this is also in the schema). The description adds value by grouping required fields per action, but the schema already provides solid documentation.

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?

Tautological: description restates name/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 description provides explicit guidance on when to use each action (add participants, remove participants, update role), when not to use it (e.g., 'do not re-add the caller'), and suggests alternatives like using 'listMeetingContacts' to resolve email. It also mentions prerequisites like requiring the meeting `{id}`.

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 idempotentHint=true and destructiveHint=true. The description goes well beyond by detailing exactly what happens for each action: create returns 201 with an id and the caller is auto-added as owner; delete is soft and returns 204/404/403; update is a PATCH with partial update semantics. It also explains error codes (403, 404, 402) and idempotency behavior for deletes. 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 well-structured with clear action sections and uses bullet-like formatting. It is moderately lengthy but every sentence adds value. Minor redundancy in repeating 'Use this when...' for each action could be tightened, but overall it's efficient and front-loaded with the main purpose.

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

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

With 9 parameters and no output schema, the description comprehensively covers return codes (201, 204, 403, 404, 402), behavioral nuances for each action, and idempotency handling. The annotations handle safety, and the description fills in all remaining context. No gaps are apparent for an agent to misuse this 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 100%, so each parameter already has a description. The description adds value by grouping parameters per action, explaining behavioral nuances (e.g., 'nulling start makes the meeting untimed'), and clarifying conditional requirements like is_instant for create. It could have explained detail_level and template_id more, but given schema already covers them, a 4 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?

Tautological: description restates name/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 description provides explicit when-to-use guidance for each action (e.g., 'Use this when the user wants to cancel or delete a meeting'). It also tells the agent NOT to re-add the owner via v1AddMeetingParticipants when creating, and suggests using Idempotency-Key to prevent duplicates. Alternatives are named ('use those dedicated tools') for participants, agenda/backlog items, and action items.

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 readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the agent knows this is a safe, non-destructive read operation. The description adds value by stating that filters are 'combined with AND' and that pagination is available via 'limit/offset'. It also transparently notes that 'summary_notes is not returned here; fetch via v1GetMeeting', which is important behavioral context. The only minor gap is that it doesn't explicitly state the search scope is limited to meetings the caller participates in, but that is implied. Given the strong annotations, the description adds sufficient extra 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 efficiently structured into two paragraphs. The first paragraph is a clear, front-loaded usage guide with alternatives and workflow hints. The second paragraph systematically lists all filters with their formats and behaviors. Every sentence provides unique value, with no redundancy or wasted words. The structure is logical and 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?

Given the tool's complexity (9 optional parameters, pagination, AND logic, no output schema for return values), the description is complete. It covers the search scope, filter semantics, pagination, a notable omission ('summary_notes'), and a crucial workflow hint for resolving names to emails. The output schema is present, so return value details are not needed. No gaps are apparent.

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 the schema already documents all 9 parameters. The description adds value by explaining the logical combination of filters (AND), providing concrete examples of acceptable values for status ('scheduled or completed'), and clarifying the format for date parameters ('ISO 8601 with timezone'). It also groups parameters conceptually (e.g., listing filters together). However, it doesn't add syntax or detailed format for every parameter beyond what's in the schema, which is acceptable given 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?

Tautological: description restates name/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 description provides explicit guidance on when to use this tool: 'Use this when the user gives keyword, date, participant, or status criteria.' It also gives clear alternatives: 'use listMeetings for plain browsing or listUpcomingMeetings for the next scheduled ones.' Additionally, it offers a workflow hint: 'If the user only has a name or initials, use listMeetingContacts... to resolve the email first, then search by participant_emails.' This is exceptional usage guidance.

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