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 readOnly/idempotent/non-destructive, and the description adds substantial behavioral context: content is a Postgres cache that may lag live edits, content_version is not a concurrency token, role reflects effective access, and inaccessible/unknown canvases return 404. 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 but information-dense, with purpose front-loaded and each sentence adding a distinct behavioral fact. No filler or restatement beyond the purposeful first sentence.

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

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

With an output schema present, the description need not restate return fields. It covers cache lag, concurrency caveat, required live lookup before edits, role semantics, and 404 behavior, making the tool's call context 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% ('Canvas ID') and the description does not add further meaning to the id parameter. The 404 behavior for unknown/inaccessible canvases is useful but relates to error semantics rather than parameter syntax or format, so the baseline of 3 applies.

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 scopes when to use: 'Use this for a cheap look... when exact up-to-the-second content is not required.' It also tells the agent to call v1GetCanvasContent before editing to get the live body and etag, making the alternative and exclusion explicit.

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 it's a safe, read-only operation. The description goes beyond annotations by clarifying that it reads the live collaborative document rather than the cache, and explains the 502 error behavior and permission levels (viewers can read, editors can replace). These are useful behavioral details not captured by 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 succinct and front-loaded with the core purpose and usage context. Every sentence adds value: the first states the action and ETag, the second explains the live read and the ETag's role, the third gives error handling and permissions. 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 simplicity (one parameter) and the presence of an output schema (which likely describes the response structure), the description covers all necessary operational details: what it returns (body + etag), how to use the etag, error handling, and permission model. 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?

The schema already documents the id parameter with 100% coverage, so the description adds no new parameter-specific meaning. The baseline for high coverage is 3, and the description doesn't enhance the parameter beyond what's in the schema.

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

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

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: 'immediately before rewriting a canvas' to guard against concurrent edits. It also tells the agent to pass the etag as If-Match on the update tool, and mentions the 502 retry behavior. This provides clear operational 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 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?

Annotations cover read-only and idempotent, but the description adds substantial behavioral detail: summary_notes content varies by tier, applied_template_ids update asynchronously and require polling, redirect_to_meeting_id signals merges, and 404 for unknown/inaccessible ids. These go far beyond the basic annotation hints and help the agent handle edge cases 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 structured into two clear paragraphs: the first states purpose and when to use, the second covers behavioral nuances. It is concise, front-loaded, and every sentence adds value—no fluff 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?

For a single-parameter read tool, this is thorough. It covers important return fields (summary_notes, applied_template_ids, redirect_to_meeting_id), tier differences, polling guidance, and error behavior (404). The presence of an output schema further reduces the need to describe returns, but the description still provides valuable context an agent needs to correctly interpret results.

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

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

The schema already describes the single `id` parameter with 100% coverage, so the description doesn't need to explain it. The description references `{id}` but adds no additional semantic meaning about the parameter's format, constraints, or usage beyond what the schema provides. 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?

It explicitly says 'Use this when the user asks about a specific meeting by id' and lists the alternatives and their conditions. It also provides guidance on when not to use it (e.g., to list meetings, use listMeetings or searchMeetings). This gives clear, actionable usage context.

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

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

Annotations already 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?

Despite the annotations already declaring readOnlyHint=true and idempotentHint=true, the description adds valuable behavioral context: it warns that the results serve "Postgres metadata plus the cached Markdown body" and that ranking can trail live edits by a few seconds. This caching caveat is not captured in annotations or schema and helps set expectations about freshness.

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 opens with the core purpose in the first sentence, then adds caching context, parameter specifics, and an alternative tool in a compact, logical flow. Each sentence earns its place, and there is no fluff or repetition of schema/annotation 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?

With an output schema present, the description does not need to explain return values, and it covers the essential operational concerns: search vs. list mode, workspace inclusion, pagination, and how to fetch the live body. It is complete for a read-only list/search tool of this complexity.

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

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

The input schema already describes all parameters with 100% coverage, so the baseline is 3. The description adds meaning beyond the schema by explaining that `q` "runs hybrid full-text search over title and body; omit it to list" and clarifying the effect of `include_workspace=true`. This enriches the agent's understanding of parameter behavior without repeating basic types.

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

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

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 gives when-to-use guidance: "Use this to find a canvas by title or body text before reading or editing it." It also provides an alternative by directing the agent to "Use v1GetCanvasContent to read the live body of a result." This makes the choice between listing/searching and reading clear.

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

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

Annotations already declare 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?

Annotations already mark this as read-only, idempotent, and non-destructive. The description adds meaningful behavioral context beyond that: newest-first ordering, limit/offset pagination, the total field as the stop signal, and the fact that items are summary views that never include summary_notes.

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 structured: it opens with scope, immediately routes to alternatives, then covers ordering, pagination, and payload limitations. Every sentence adds information and there is no filler or repetition of schema 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?

With an output schema present and annotations covering the safety profile, the description only needs to convey selection logic and behavioral details. It does so completely: when to use this tool, how pagination works, what summary views exclude, and which alternative provides full details.

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 fully documents limit and offset with defaults and ranges, so the baseline is 3. The description adds useful pagination semantics by saying how the two parameters work together and that the response total tells you when to stop paginating, which helps an agent use the parameters correctly.

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 gives clear when-to-use guidance: use this to see all meetings, prefer searchMeetings for keyword/date/participant/status, prefer listUpcomingMeetings for soonest future ones, and use v1GetMeeting for full details. The only small gap is that v1GetMeeting is not an exact match to the sibling tool name getMeeting, which may cause slight resolution ambiguity.

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

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

Annotations already mark it readOnly/idempotent/non-destructive; the description adds behavioral detail beyond that: caller-visible template scopes, additive application semantics, async-vs-sync timing, pagination defaults, and absence of paid-tier gating. 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 text is denser than necessary (e.g., 'Browse meeting templates' and 'Use this to see available templates' overlap), but it front-loads the primary purpose and every additional sentence contributes operational value. Well-structured into purpose and follow-up 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?

For a simple paginated list with an output schema, the description covers all operational context: scope, pagination, downstream usage, application timing, and gating. Nothing an agent needs to call it 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 100% and only two parameters exist, so baseline is 3. The description adds the default limit of 20 and frames limit/offset as pagination, which is meaningful behavior not present in 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?

Explicitly says 'Use this to see available templates' and instructs passing the returned id to v1CreateMeeting or v1UpdateMeeting. It even clarifies async vs synchronous application, so an agent knows when this tool is the right first step.

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

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

Annotations already declare readOnlyHint and idempotentHint, so the safety profile is covered. The description adds valuable behavioral details: it lists only future meetings, sorts soonest first, supports pagination with limit/offset, exposes a total field to signal stopping, and returns summary views rather than full details. 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 compact and front-loaded, with the core purpose and usage guidance in the first two sentences. There is mild redundancy between 'soonest future meetings' and 'Lists the caller's upcoming (future) meetings, soonest first,' so it is not perfectly tight, but it avoids unnecessary padding.

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

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

For a simple read-only listing tool with a rich output schema, the description covers everything an agent needs: what is returned, ordering, pagination mechanics, when to stop, and where to go for full meeting details. It is complete without over-explaining.

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 for limit and offset is 100%, which establishes the baseline at 3. The description adds operational context beyond the schema by explaining that pagination uses limit/offset and that the response's total field indicates when to stop, which helps an agent paginate correctly.

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 gives direct when-to-use guidance: 'Use this when the user asks what is coming up.' It also names the alternatives and their distinct purposes: listMeetings for browsing all meetings and searchMeetings for filtering by criteria, leaving no ambiguity about route selection.

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

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

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 declare readOnlyHint=false, idempotentHint=true, and destructiveHint=true. The description goes far beyond these, disclosing detailed behaviors: soft-delete semantics, owner-only access with 403/404 errors, ETag guards and 409 handling, error codes (400, 402, 422), idempotency via Idempotency-Key, default workspace roles, and explicit no-restore guarantee. It enriches the annotation profile with concrete operational details and does not contradict any annotation.

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

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

The description is long but appropriately structured: it opens with the overall purpose and the key distinction between replaceContent and update, then breaks down each action in a consistent format. Every sentence carries operational weight—no filler. The front-loaded summary ensures an agent immediately understands the core usage pattern, and the per-action sections provide depth where needed.

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 complex tool with 8 parameters, no output schema, and four distinct operations, the description is exhaustive. It covers every action's inputs, prerequisites, error conditions, retry guidance, and access requirements. It addresses edge cases like stale ETags, template readability, idempotency, and soft-delete behavior. No critical information appears missing; an agent can invoke this tool correctly across 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?

The input schema already describes all 8 parameters with 100% coverage, so the baseline is 3. The description adds substantial meaning beyond the schema: it explains that content is ignored when template_id is supplied, that If-Match must be the ETag from a prior read, that Idempotency-Key prevents duplicates, and that workspace_canvas_role defaults to NOACCESS. These enrichments clarify relationships and constraints that the schema alone does not convey.

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: 'Use this when the user wants a new document' for create, 'Use this only when the user explicitly wants a canvas removed' for delete, 'Use this to rewrite a canvas after reading it with getCanvasContent' for replaceContent, and 'Use this for metadata changes' for update. It also names the alternative tools for reading (getCanvas, getCanvasContent) and states exclusions like 'never merge blindly' on 409. This leaves no ambiguity about selection.

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

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

Annotations 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 only provide high-level hints (readOnly=false, idempotent=true, destructive=true). The description adds substantial behavioral detail: soft-delete semantics, idempotency via Idempotency-Key, async template application on create requiring polling, sync additive application on update, error codes (403/404/402/503), and ownership constraints for delete. It does not contradict annotations and provides comprehensive beyond-annotation 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 long but well-structured. It front-loads the purpose and usage, then segments each action into its own block. Every sentence carries relevant operational detail (return codes, idempotency, ownership rules, polling requirements). While slightly verbose, it is organized logically and efficiently for a complex multi-operation tool.

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 (three operations, nine parameters, async behavior, error handling), the description is remarkably complete. It covers return status codes (201, 204, 403, 404, 402, 503), idempotency considerations, template application semantics, and partial update rules. No critical operational detail 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% with each parameter already described. The description goes further: for 'action' it explains each enum value's behavior; for 'template_id' it explains async vs sync application based on action; for 'Idempotency-Key' it explains replay behavior; for 'start_time'/'end_time' it explains ISO-8601 and null semantics. This adds meaning not present in the schema, fully compensating for any gaps.

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 the tool: 'Use this when the user wants to schedule, edit, or cancel a meeting.' It also names alternatives and conditions, such as not using v1AddMeetingParticipants to re-add the caller as owner. Each action (create, delete, update) has its own when-to-use guidance, fully covering usage context.

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

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

Beyond the readOnly/idempotent annotations, the description reveals meaningful behavior: access scope (link-only shares excluded), relevance ordering when q is used, match_context presence conditions, pagination semantics, and the fact that summary_notes is omitted. These details materially help an agent predict outcomes.

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 every sentence carries load: usage routing, access scope, filter semantics, ordering, pagination, and return-value caveats. It is front-loaded with the most important selection guidance and uses structured punctuation to keep the detail scannable.

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 optional parameters, no required fields, and an output schema, the description covers everything an agent needs to invoke this correctly: when to use it, what it returns, how results are ordered, how to paginate, and what is intentionally absent. No critical operational detail 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?

Even though schema coverage is 100%, the description adds important semantic nuance: q performs full-text matching over notes and supports quoted phrases/exclusions, status values are enumerated, participant_emails is comma-separated, and filters combine with AND. This goes well beyond the baseline 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?

It explicitly says when to use this tool ('when the user gives keyword, date, participant, or status criteria'), names alternatives for other cases, and even provides a resolution path for name-only queries via listMeetingContacts. This is exemplary routing guidance with no ambiguity left to inference.

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