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

With no annotations provided, the description carries the full behavioral burden. It clearly discloses that this starts an interactive OAuth consent flow and opens a browser for sign-in, which are the key side effects. It could additionally mention that the flow requires user interaction or that a token is stored after successful sign-in, but the core behavior is transparent.

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

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

Two short sentences with no filler. The main action ('Start the OAuth consent flow') is front-loaded, and the browser behavior is stated immediately after.

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 two-parameter interactive tool, the description covers the initiation, the mechanism, and the user-visible behavior. It does not describe the post-sign-in result or the fact that the flow is blocking/interactive, but these are not critical given the overall simplicity and fully described schema.

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

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

Schema coverage is 100%, so the schema already fully documents both parameters. The description adds little beyond the schema, though 'new Google account' reinforces that the name parameter is a nickname for a newly linked account. Baseline 3 is appropriate.

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

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

The description uses a specific verb and resource ('add'/'connect a new Google account') and clearly names the OAuth consent flow as the mechanism. It is easy to distinguish from sibling account-management tools like google_account_remove, google_account_set_default, google_account_list, and google_account_status.

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 purpose implies when to use it: when a new Google account needs to be connected. However, it does not explicitly mention when not to use it or point to alternatives such as google_account_list for checking connected accounts or google_account_remove for removing an existing one.

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

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

With no annotations, the description carries the full burden. It discloses the output fields (email, default status) and implies a read-only operation through 'List all.' However, it does not explicitly state that it is safe and non-destructive, nor does it mention any authentication prerequisites or response format beyond the fields listed. This is adequate for a simple read tool but lacks depth.

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

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

The description is a single concise sentence that front-loads the action ('List all connected accounts') and adds essential detail ('with their email and default status'). Every word earns its place, with 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 simple list tool with no parameters, no output schema, and no annotations, the description is fairly complete. It states what is returned (email and default status), implying a collection result. It doesn't mention the exact return format or any edge cases, but given the low complexity, this is sufficient. A slight gap is the lack of explicit statement that it lists all accounts across all connections, though 'all connected accounts' conveys that.

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

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

The tool has zero parameters, and the schema coverage is 100% (effectively no parameters). According to the baseline for 0 params, a score of 4 is appropriate. The description does not need to elaborate on parameters since there are none, and the absence of any parameter mention is acceptable.

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

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

The description clearly states the tool's function: 'List all connected accounts with their email and default status.' It identifies the resource (connected accounts) and the specific action (list all). It differentiates from siblings like google_account_add/remove/set_default by indicating a read operation, but does not explicitly contrast with google_account_status, so it doesn't fully distinguish itself.

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

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

There is no guidance on when to use this tool versus alternatives. The description only states what it does, without mentioning that it should be used when you need an overview of all accounts, or that google_account_status might be used for a single account. No exclusions or alternative tool references are provided.

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

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

With no annotations, the description carries the full burden of disclosure. It does state the destructive effect clearly ('delete its stored tokens'), which is useful, but it omits important side effects such as requiring re-authentication, breaking dependent Google tools, or irreversibility of the token deletion.

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?

One sentence with no filler, front-loading the key action. It is appropriately concise for a simple tool, though it could earn a 5 by including a short clause about re-authentication or side effects without becoming verbose.

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

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

Given the low complexity and single well-documented parameter, the description is mostly adequate, but the lack of annotations and output schema leaves the return value, success/failure behavior, and impact on connected tools undisclosed. For a destructive account operation, slightly more context would make it complete.

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

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

The schema already provides 100% coverage for the single parameter, describing 'name' as 'Account nickname to remove'. The description adds no further meaning, so the baseline of 3 applies because the schema handles the parameter documentation sufficiently.

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

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

The description uses precise verbs ('Disconnect', 'delete') and a specific resource ('stored tokens'), clarifying that this removes local credential access rather than deleting a Google account. This distinguishes it from sibling tools like google_account_add, google_account_set_default, and google_account_status.

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

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

No guidance is provided about when to use this tool versus alternatives, nor any indication of prerequisites or consequences. The intended context can only be inferred from the tool name and the word 'Disconnect', which is not proactive enough for an agent deciding between account-management 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?

No annotations are provided, so the description carries the full behavioral burden. It states the core state change but does not disclose side effects, persistence, authentication requirements, error behavior, or what happens if the nickname is invalid. This is a minimal disclosure for a mutating tool.

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

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

The description is a single, front-loaded sentence with no filler. Every word contributes to the meaning, making it easy for an agent to parse quickly.

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

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

For a simple one-parameter setter, the description and schema are mostly adequate, but with no annotations and no output schema, the agent is left without information about return values, side effects, or whether the nickname must already exist. It is minimally viable but has clear gaps.

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

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

The input schema covers the single parameter completely with 'Account nickname to use as default.' The description adds no further parameter-level meaning, so it neither enhances nor detracts from the schema. Baseline 3 is appropriate given full schema coverage.

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

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

The description uses a specific verb ('Set') and resource ('default Google account') and clarifies the behavior with 'when no account is specified.' This distinguishes it clearly from sibling account tools like google_account_add, google_account_list, google_account_remove, and google_account_status.

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

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

The description implies when the default matters ('when no account is specified') but does not explicitly state when to invoke this tool versus alternatives, nor does it mention prerequisites such as the account needing to exist. Usage context is present but not fully articulated.

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

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

With no annotations provided, the description must disclose behavioral traits. It says 'Show', implying a read-only operation, and lists the information categories, which gives some transparency. However, it does not mention potential side effects (e.g., token refresh) or failure conditions, nor the exact format of the output. For a status tool, this is adequate but not fully transparent.

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

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

The description is a single, front-loaded sentence that directly states the action and key objects. It is appropriately concise, with no filler words or repetitive details, making it efficient for an agent to parse and act upon.

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

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

The tool is simple: no parameters, no output schema, and no nested objects. The description adequately covers the scope by enumerating the four content areas (credential config, data directory, connected accounts, token health). While it does not detail return structure, the lack of complexity makes this listing sufficient for the agent to understand the tool's purpose and invoke it 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 tool has zero parameters and the schema is empty, so there is no parameter semantic burden. Per the rubric, the baseline for 0 params is 4; the description adds no confusion and correctly implies no inputs are needed. The schema coverage is effectively 100%, so the description is not required to compensate.

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

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

The description begins with the action 'Show' and specifies four concrete subjects: 'credential configuration, data directory, connected accounts and token health'. This clearly identifies the tool's function and differentiates it from sibling tools like google_account_list (which only lists accounts) by focusing on broader status/health information.

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

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

No explicit guidance is given about when to use this tool compared to alternatives such as google_account_list (account listing only) or google_account_add/remove (account management). The description states what it does but not when it should be preferred over sibling tools, leaving the agent to infer 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?

No annotations are provided, so the description carries full burden. It does not disclose permission/scope requirements, whether the new calendar becomes visible in the calendar list, whether it is set as default, or what is returned. It only identifies the entity being created.

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

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

A single front-loaded sentence with no filler; the entity and its configurable attributes are immediately clear.

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

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

For a mutation tool with no annotations and no output schema, the description is thin: it omits required fields (only 'summary' is required, yet the sentence implies all three are expected), permission needs, and side effects. An agent can guess how to call it but not the consequences.

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

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

Schema coverage is 75%, with the 'description' property undocumented in the schema. The description merely restates the three named fields without adding format, constraint, or interaction detail, so it does little beyond the schema.

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

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

The description states a specific verb (Create) and resource (a secondary calendar), plus the fields it accepts. Calling it 'secondary' distinguishes it from editing the primary calendar, though no sibling is named explicitly.

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

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

There is no guidance on when to use this versus google_calendar_create_event, google_calendar_create_meet, or google_calendar_update. The word 'secondary' hints at scope but the agent must infer that this does not create events or meet links.

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

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

With no annotations, the description carries the full behavioral burden and falls well short. For a mutation tool it says nothing about attendee invite emails, sendUpdates defaults, reminder behavior, or required auth/scopes. The one useful nugget is the all-day date convention, but that duplicates the schema.

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

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

Two short sentences, no filler, and the primary purpose is front-loaded ahead of the format note. Every sentence earns its place, even if the total content is thin.

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 16-parameter mutation tool with no annotations and no output schema, a two-sentence description is inadequate. Aspects like attendee notification control, recurrence/timezone interaction, and default behavior are left entirely to the schema, leaving meaningful gaps 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 88%, so the schema already documents nearly all 16 parameters, giving a baseline of 3. The description's only parameter-related content (all-day YYYY-MM-DD dates) merely restates what the start/end schema descriptions already say, adding no new semantics.

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

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

States a specific verb and resource ('Create a ... event') and distinguishes two modes (timed vs all-day). It does not differentiate itself from nearby siblings such as google_calendar_create, google_calendar_update_event, or google_calendar_create_meet, so an agent gets the core action but no explicit routing signal.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives like google_calendar_create or google_calendar_create_meet. The only guidance offered is a date-format note for all-day events, which is a formatting rule rather than usage direction.

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

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

With no annotations, the description carries the full behavioral burden, but it only states the high-level effect. It does not disclose whether a Meet conference is actually created, what permissions/auth are required, what the response contains, or other side effects. This is a significant gap for a mutation tool.

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

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

A single, front-loaded sentence with no filler; every word contributes to selecting and understanding the tool's purpose.

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

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

Despite a well-described schema, the definition lacks an output schema and provides no usage alternatives, return behavior, or auth/side-effect context. For a 7-parameter mutation tool with no annotations, this is too thin to be fully actionable.

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

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

Schema description coverage is high (86%) and parameter descriptions already define meaning. The tool description adds no parameter-level detail, so the baseline 3 is appropriate.

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

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

States a specific verb and resource ('Create a calendar event') with a concrete differentiator ('attached Google Meet link') that distinguishes it from the sibling google_calendar_create_event. An agent can tell exactly what this tool produces.

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

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

Usage is implied: choose this when a Google Meet link is needed. However, it does not explicitly mention when not to use it or point to google_calendar_create_event as the plain-event alternative, so routing depends on inference.

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

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

With no annotations, the description carries the full burden, and it does disclose the key trait that the deletion is permanent and destructive. However, it omits whether contained events are also destroyed, whether this is reversible, and any permission/auth requirements, leaving meaningful behavioral gaps for a mutation tool.

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

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

A single short sentence with the destructive nature parenthesized at the end; nothing is wasted and the purpose is front-loaded.

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

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

For a simple two-parameter delete with a fully documented schema, the description covers purpose and the destructive/permanent trait. But with no annotations and no output schema, it should say more about consequences (e.g. collateral deletion of events) and would-be-restricted behavior to be 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 description coverage is 100% for both parameters, so the schema already documents calendarId and account. The description adds no syntax, format, or sourcing detail beyond the schema, so the baseline 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?

States a specific verb and resource ("Delete a secondary calendar") and adds the scoping qualifier "secondary," which separates it from primary-calendar operations. It also implicitly distinguishes from the sibling google_calendar_delete_event by naming a calendar rather than an event, though it never makes that distinction explicit.

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

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

There is no when-to-use or when-not-to-use guidance and no mention of alternatives, prerequisites, or how to react if the calendarId refers to a primary calendar. The only usage signal is the word "secondary," which constrains scope but is not framed as 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?

No annotations are present, so the description carries the full burden of behavioral disclosure. 'Delete' implies a destructive action, but the description does not state that deletion is permanent, require any special permissions, or describe side effects such as handling of recurring events. It adds no behavioral context beyond what the tool name already implies.

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

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

The description is a single short sentence, 'Delete an event by ID,' with no filler or redundant information. It is front-loaded with the action and the key qualifier, making it extremely efficient and easy to parse.

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

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

For a simple delete operation with full schema coverage and no output schema, the description provides the essential action and target. However, it omits additional context such as irreversibility, default calendar behavior (though schema covers calendarId default), and any permission requirements. Given the low complexity, this is minimally adequate but not thorough.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters. The description mentions 'by ID', which only highlights the required eventId but adds no new meaning beyond the schema's 'Event ID.' Baseline 3 is appropriate because the description does not compensate for or enhance the parameter semantics.

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

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

The description 'Delete an event by ID' uses a specific verb (delete) and resource (event) and clearly identifies the key parameter (ID). It distinguishes the tool from sibling calendar tools like create/update/get and from delete tools in other services, so an agent can immediately know its purpose.

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

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

No guidance is provided on when to use this tool versus alternatives such as google_calendar_update_event or when deletion would be inappropriate. The description simply states the action without any context, prerequisites, or exclusions, leaving the agent to infer usage from the name alone.

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

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

With no annotations, the description carries full burden, and it does add one meaningful disclosure: the tool returns BUSY intervals from which the agent must derive free windows (not a ready-made list of free slots). However, it omits permissions, rate limits, error behavior, and return shape for what is otherwise an undocumented read.

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?

A single front-loaded sentence with no filler, and the core action is stated first. It is efficient, though arguably under-specified for a tool with no annotations and no output schema.

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

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

The purpose is adequately conveyed, but with no annotations and no output schema, the description should carry more behavioral weight than it does. It gestures at return content (busy intervals) but leaves return format, permissions, and calendar-ID defaults unaddressed.

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 all five parameters (items, account, timeMin/timeMax, timeZone) are already documented in the schema. The description adds only a hint via "across calendars" and nothing about the required timeMin/timeMax or defaults, so the baseline 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?

The description names a specific verb ("Query") and resource ("busy intervals across calendars") and states the goal ("find free meeting windows"). This clearly distinguishes it from siblings like list_events or get_event, though it does not name those siblings explicitly to route the agent.

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

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

Usage is only implied: an agent can infer it should call this before scheduling a meeting, but there is no explicit when-to-use, when-not, or reference to alternatives such as google_calendar_list_events for actual event details.

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

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

With no annotations, 'Fetch' indicates a read-only retrieval, but the description doesn't add context about account/calendar defaults, errors, or returned data. It is transparent on side-effect risk but thin on operational behavior.

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

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

One sentence with no filler, front-loading the verb and resource; max signal per token.

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?

Adequate for a simple fetch tool: schema supplies parameter details and defaults, but no output guidance or operational context beyond the core action, and there is no output schema to compensate.

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

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

Schema covers all 3 parameters with descriptions, so baseline is 3; the description only reinforces that eventId is the lookup key and adds no new parameter meaning.

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

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

States a specific verb ('Fetch'), a clear resource ('calendar event'), and a selection criterion ('single event by ID'), which distinguishes it from sibling list/create/update/delete event tools.

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

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

The word 'single' implies use when you have an event ID rather than listing or creating events, but the description provides no explicit when-to-use guidance or alternatives.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states that the tool lists calendars the account can access, but it does not mention whether it requires specific permissions, whether it fetches all calendars or only default ones, or what the return format is. There is no contradictory information, but the description is thin on 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 a single sentence that is concise and front-loaded with the action. It does not waste words, but it could be slightly more descriptive without losing conciseness. However, given the simplicity of the tool, this level of conciseness is appropriate.

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

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

The tool is relatively simple, but with no annotations and no output schema, the description should at least mention what the return value is (e.g., a list of calendar names and IDs). The lack of such detail leaves the agent uncertain about the output format and whether it needs to handle pagination or large result sets. Thus, the description is incomplete for agent decision-making.

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

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

The input schema has 100% description coverage for the only parameter, 'account', which clearly states 'Account nickname to use.' The description adds no extra meaning beyond the schema, but since the schema is fully descriptive, the parameter semantics are adequately covered. The description does not need to add more as the schema is sufficient.

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

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

The description states a clear verb ('list') and resource ('calendars'), but it does not differentiate this tool from closely related siblings like google_calendar_list_events. It is distinct enough that an agent can infer it lists calendars, not events, but it lacks explicit distinction.

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

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

There is no guidance on when to use this tool over alternatives, such as when to list calendars versus events. The context implies it is for retrieving available calendars, but it does not state when not to use it or mention alternatives. The agent is left to infer usage solely from the tool name and siblings.

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

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

With no annotations, the description carries the full behavioral burden; it accurately signals a read-only listing operation and the optionality of time/query filters. However, it does not disclose default behavior such as default calendarId, default maxResults, or that events are returned for a default time range starting now, leaving some behavior for the agent to infer.

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

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

The description is a single front-loaded sentence with no redundancy; it conveys the core operation and optional filters in minimal space.

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 fully documented parameters, the description plus schema covers the essential information an agent needs. It could be marginally more complete by naming common sibling alternatives or clarifying return contents, but neither is required for correct invocation.

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

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

Schema description coverage is 100%, so the six parameters are already fully documented in the input schema. The description only restates the filtering concepts (time range and query) rather than adding new semantic detail about parameter values or interactions.

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

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

The description names a specific action, 'List upcoming events in a calendar,' with optional filters, which clearly tells an agent what the tool does. It is distinct from sibling calendar event create/get/update/delete tools, though it does not explicitly contrast with the sibling get_event for single-event retrieval.

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?

'Optionally filtered by time range or query' implies when the tool is useful, but there is no explicit guidance about when to prefer this over google_calendar_get_event or google_calendar_list_calendars, nor any exclusions or prerequisites such as needing an account or calendarId.

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

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

No annotations are provided, so the description carries the full behavioral burden and falls short. It never states that this mutates your attendee record on the event, that sendUpdates defaults to none (so invitees may not be notified), or whether the change is reversible. Only the mechanism (setting responseStatus) is disclosed.

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

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

A single efficiently front-loaded sentence with no filler; the action set leads and the mechanism follows. It could be one notch richer without bloating.

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

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

For a mutation tool with zero annotations and no output schema, the definition is adequate but thin: it omits side effects (notification behavior, whose attendee entry is affected) and return information. An agent can invoke it, but not with full confidence about consequences.

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%, with documented enums for responseStatus and sendUpdates and clear notes for email, account, and calendarId defaults. The description adds the responseStatus semantics but nothing beyond what the schema already conveys, so baseline 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?

The description states a specific action set (accept, decline, mark tentative) on a specific resource (an event invite) via the responseStatus field. It is clearly distinguishable from generic calendar mutators like update_event, though it never names a sibling explicitly.

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

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

Usage is implied by the verb set: you call this when you want to RSVP to an invite. There is no explicit when-to-use versus google_calendar_update_event, no note that this targets your own attendee entry rather than the event body, and no prerequisites.

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

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

No annotations are provided, so the description carries the full burden. '(partial)' usefully discloses that unspecified fields are left untouched, but the description says nothing about permission requirements, whether the change is reversible, or what happens to fields not passed.

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?

A single front-loaded sentence with no filler. It is efficient, though it is arguably too terse to be maximally helpful for a mutation 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?

For a 6-parameter mutation tool with no annotations and no output schema, the description is thin. It omits when-to-use context, prerequisites, and behavioral details an agent needs to invoke it confidently.

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

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

Schema description coverage is 83%, so the schema already documents calendarId, colorId, summary, timeZone and account. The description only restates the same field set in prose, adding no format or constraint detail beyond what the schema provides. Baseline 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?

States a specific verb (Update) and resource (a calendar) plus the exact editable fields (name, color, timezone, description), which distinguishes it from the sibling google_calendar_update_event. It is clear, but it does not explicitly name the sibling it is not to be confused with.

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

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

There is no guidance on when to use this tool versus google_calendar_create or google_calendar_delete, nor any prerequisites. The only hint is the parenthetical '(partial)', which does not tell the agent when this operation is appropriate.

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

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

With no annotations, the description carries the full behavioral burden, and "partial update" is the only real disclosure — it usefully signals that unspecified fields are preserved. However, it says nothing about side effects (attendee notification emails triggered by sendUpdates), permission/auth requirements, whether changes are reversible, or how recurrence edits behave, all of which matter for a 17-parameter mutation.

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?

A single front-loaded sentence with zero filler, and the partial-update qualifier is placed where it is read first. It is arguably under-sized for a 17-parameter tool, which keeps it just short of a 5.

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 large mutation tool with no annotations, no output schema, and only one required parameter, a one-line description leaves the agent without the behavioral context it needs (notification side effects, auth, recurrence caveats). It is far too thin relative to the tool's complexity, even though the schema covers most parameter detail.

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 82%, well above the threshold where the schema does the heavy lifting, and the description adds no parameter-level detail whatsoever. Baseline 3 applies: the schema documents start/end/timeZone/recurrence/attendees semantics itself.

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

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

States a specific verb and resource ("Update fields of an existing event") and clarifies scope with "(partial update)." It distinguishes update from create/delete siblings, though it does nothing to differentiate itself from the similarly named google_calendar_update sibling.

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

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

There is no guidance on when to use this tool versus google_calendar_update, google_calendar_create_event, or google_calendar_respond, nor any statement of prerequisites such as needing an existing eventId or write access. The parenthetical "partial update" implies behavior but never states when a partial update is the right choice.

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

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

No annotations are provided, so the description carries the full disclosure burden for a mutation tool. It says nothing about permissions, duplicate handling, reversibility, or whether the created contact is returned with an identifier; 'create' alone is the only behavioral signal.

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?

A single front-loaded sentence with no filler. It is efficient, though it leaves out one parameter (account) and could have traded a few words for a usage clause.

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

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

For a 7-parameter mutation tool with no annotations and no output schema, the description is thin: it omits account selection, duplicate/validation behavior, and what the caller gets back. An agent can form a rough call but not a fully informed one.

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 57%, so the schema documents name, account, address and photoBytes but leaves email, phone and organization bare in their own definitions. The description names most of these fields and flags them as optional, which partially compensates, though it omits 'account' and adds no format or constraint detail beyond what the schema already states.

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

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

States a specific verb and resource ('Create a new contact') and enumerates the payload fields, so an agent can distinguish it from google_contacts_get/list/search/update/delete. It stops short of any sibling-specific routing language, so it is clear but not maximally differentiated.

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

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

There is no guidance on when to create versus update an existing contact, no prerequisites, and no mention of which account context applies despite the sibling set containing google_account_list/set_default/add. The agent must infer all usage conditions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure and does not meet it. It never states whether the deletion is permanent or reversible, whether the contact moves to a trash/recoverable state (as sibling google_gmail_trash implies is a pattern in this API surface), or what permissions are required. For a destructive operation this is a substantial gap.

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?

A single short sentence with zero filler, front-loaded with the action. It is efficient, though the brevity borders on under-specification for a destructive tool rather than true conciseness.

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

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

For a delete tool with no annotations and no output schema, the description says nothing about irreversibility, error behavior for a bad resourceName, or side effects. An agent has enough to form the call but not enough to judge whether calling it is safe.

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% and the schema already documents both `resourceName` (with an example format) and `account`. The description names resourceName but adds no syntax, format, or validation detail beyond what the schema supplies, so baseline 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?

States a specific verb and resource ('Delete a contact') and identifies the keying parameter ('by resourceName'), so an agent immediately knows the operation. It does not differentiate itself from siblings such as google_contacts_update or google_contacts_get, relying on the tool name to do that work.

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

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

No when-to-use or when-not-to-use guidance is given, and no alternative is named. The only hint at context is the schema note that resourceName comes 'from list/search', which is not in the description itself.

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

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

With no annotations, the description carries the full behavioral burden but discloses only that this is a read operation ('Get') and what fields it returns. It omits auth requirements (including how the 'account' nickname affects access), error handling for a missing contact, and any rate-limit 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?

A single, front-loaded sentence that packs purpose and return fields without filler. It is appropriately sized for a simple getter.

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

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

For a low-complexity getter with complete schema coverage and no output schema, the description covers purpose and return fields but omits usage routing and behavioral details. An agent would still benefit from knowing when to prefer this over list/search.

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 no parameter details beyond the required 'resourceName' and the returned-field list. The optional 'account' parameter's nickname semantics are left entirely to 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?

States a specific verb and resource ('Get a contact') and scopes it by 'resourceName', while listing the rich fields returned. This implicitly distinguishes it from the collection-returning siblings google_contacts_list and google_contacts_search, but it does not name those alternatives.

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

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

No explicit when-to-use or when-not-to-use guidance; it neither names alternatives like google_contacts_search nor states prerequisites. The phrase 'by resourceName' only weakly implies the identifier must already be known, e.g., from list/search.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states that contacts are listed with names, emails, and phones, providing partial output context, but does not mention whether the operation is read-only, pagination behavior, or authentication requirements. This is a significant gap for a tool without 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 single, front-loaded sentence that is concise and to the point, with no extraneous information. It efficiently conveys the core purpose and key output fields.

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

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

Given the simplicity of the tool and the absence of an output schema, the description provides the essential field names but omits details like pagination behavior, error handling, and whether all contacts are returned without filtering. While adequate for a basic listing, it could be more complete to fully inform the agent.

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?

Both parameters (account and pageSize) are fully described in the schema, so the description does not need to add details. It adds no extra meaning beyond the schema, which matches the baseline of 3 for high schema coverage.

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

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

The description clearly states the action (list) and resource (the account's contacts), specifying the returned fields (names, emails, phones). This distinguishes it from siblings like google_contacts_search and google_contacts_create, though it does not explicitly name them. The verb and resource make the purpose unambiguous.

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

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

No guidance is given on when to use this tool versus alternatives like google_contacts_search. The description does not mention when to list all contacts versus searching for specific ones, nor any prerequisites. This leaves the agent to infer usage without explicit direction.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does add one behavioral trait: 'including non-connected' – indicating the search covers contacts beyond direct connections. However, it does not mention what the output looks like (e.g., list of contacts, pagination, ordering), or any error behavior. This is minimal disclosure for a search tool.

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

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

The description is a single, well-structured sentence that front-loads the purpose and key scope. There is no fluff or redundant information.

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

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

For a simple search tool with two parameters and 100% schema coverage, the description covers the core functionality. However, it omits any information about the return format (since there is no output schema), and it does not mention the 'account' parameter's role in the search. Given the low complexity, it is adequate but not thorough.

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

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

The schema already covers both parameters with descriptions, so the baseline is 3. The description adds value by specifying that the query can match 'name, email or phone', giving the agent a clearer idea of what to put in the query field. It does not elaborate on the 'account' parameter, but the schema already describes it as a nickname.

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

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

The description clearly states the verb (Search), the resource (contacts), and specifies the scope ('including non-connected') and search fields (name, email, phone). This distinguishes it from the sibling google_contacts_list, which presumably lists contacts without a query. The specificity is strong, though it does not explicitly name alternatives.

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

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

The description implies this tool is used when a search query is available, but it provides no explicit guidance on when to use it versus google_contacts_list or other contact tools. There is no mention of when not to use it or any prerequisites. The context is left to inference.

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

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

No annotations are supplied, so the description carries the full behavioral burden. It usefully discloses partial-update semantics (only supplied fields change), which is real behavioral value, but says nothing about auth requirements, error behavior on a bad resourceName, or whether photoBytes replaces an existing photo.

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?

One compact sentence with the verb, resource, field list, and update semantics all front-loaded; no filler and nothing redundant.

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 an 8-parameter mutation tool with no annotations and no output schema, the description covers what can be changed and that updates are partial, but omits confirmation/return behavior and failure modes. Adequate but with clear gaps.

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

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

Schema description coverage is 88%, so the schema already documents nearly every parameter; the baseline of 3 applies. The description enumerates most fields but omits 'account' and adds only the partial-update qualifier, so it does not meaningfully exceed 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?

States a specific verb (Update) and resource (existing contact) plus the exact mutable fields, and the phrase 'existing contact' implicitly separates it from google_contacts_create. It does not name the sibling explicitly, so it stops short of a 5.

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

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

Usage is only implied: 'update an existing contact' tells the agent the resource must already exist, and '(partial update by resourceName)' hints that resourceName comes from a prior lookup. There is no explicit when-to-use-vs-create guidance and no prerequisites or exclusions 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 are absent, so the description carries the full burden, but it only restates the operation and offers examples of request types. It does not disclose the operation's mutation effect on the document, what the API response contains, error behavior, or any per-call limits. This goes little beyond what the tool name already implies.

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?

Single sentence with no filler; the verb and resource are front-loaded and the parenthetical adds useful scope. It is appropriately minimal for what it conveys, though it could afford a second sentence on usage without harming 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?

With no annotations and no output schema, the description is thin for a low-level API passthrough. It omits return value shape, side effects, and how errors manifest, and it does not connect to sibling higher-level update tools. The schema's parameter coverage is complete, but the overall tool contract remains under-specified.

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

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

Schema covers all three parameters with simple descriptions, so baseline is 3. The description adds modest value by giving examples of request kinds (styles, tables, headers) that clarify the otherwise open-ended 'requests' array, but it does not explain the request object structure or required fields, leaving most semantics to the Docs API knowledge.

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?

Names a specific action ('Send raw Docs batchUpdate requests') and a resource (the document), with examples of what kinds of updates are supported (styles, tables, headers). It distinguishes from sibling read/create/text-insert tools because it targets the low-level batchUpdate endpoint, though 'batchUpdate' in the title partially duplicates that idea.

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

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

No guidance on when to choose raw batchUpdate over the higher-level google_docs_insert_text, google_docs_replace_text, or google_docs_create, nor when not to use it. The word 'raw' implies advanced use, but this is not an explicit recommendation or exclusion, so an agent must infer timing.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does disclose the core side effect: a new document is created. However, it omits account-selection behavior, default storage location, permissions, and what is returned, leaving the behavioral disclosure thin but not misleading.

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

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

The description is one short, front-loaded sentence that states the action and object immediately. Every word contributes to the core meaning and there is no boilerplate or unnecessary elaboration.

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

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

The tool is simple and the schema fully covers both parameters, so the input side is adequately specified. However, there is no output schema and the description fails to explain what is returned after creation (e.g., document ID or URL) or how the optional `account` parameter is resolved. This leaves a meaningful gap for an agent trying to use the result.

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 both `title` and `account`; the baseline is therefore 3. The description adds no new detail about the `account` parameter and only restates that a document has a title. No additional parameter semantics are introduced beyond the schema.

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

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

The description uses a specific verb and resource: 'Create a new Google Docs document.' It clearly communicates the deliverable and distinguishes this tool from sibling creation tools like google_sheets_create or google_slides_create. The word 'new' also makes the creation semantics unambiguous.

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

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

The description implies the usage context—use this when a brand-new Google Docs document is needed—but it provides no explicit alternatives, exclusions, or prerequisites. There is no guidance about when to use this instead of google_docs_batch_update or google_sheets_create, so the agent must infer the scope.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not state that the deletion is destructive/irreversible, what permissions are required, or what happens if startIndex/endIndex are out of bounds or invalid, leaving significant gaps for a mutation tool.

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

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

A single front-loaded sentence with no waste. It is efficient, though at the cost of omitting any behavioral or usage context.

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

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

For a destructive mutation tool with no annotations and no output schema, the description is too thin: it omits irreversibility, permission requirements, and any error/edge-case behavior an agent needs before invoking a delete.

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

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

Schema description coverage is 100%, and the schema already documents documentId, startIndex (0-based, inclusive), endIndex (0-based, exclusive), and account. The description adds nothing beyond the schema, 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?

States a specific verb ('Delete') and resource scope ('a range of content from a document'), so the operation is unambiguous. It does not, however, distinguish itself from its many docs siblings (replace_text, insert_text, batch_update) or say what kind of content or document structure is affected.

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

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

There is no guidance on when to use this versus alternatives such as google_docs_replace_text or google_docs_batch_update, nor any stated preconditions. An agent must infer usage entirely from the name.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the return value is 'structural JSON' and implies a read operation through 'Get', but it does not explicitly state that this is read-only, nor does it mention any permissions, side effects, or rate limits. For a simple retrieval tool, the output format hint adds some value, but more explicit behavioral disclosure would be better.

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

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

The description is a single, concise sentence that immediately states the action and the output format. There is no unnecessary verbiage, and the key information is front-loaded. It is appropriately sized for a simple get operation.

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

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

For a tool with only two parameters and no output schema, the description provides enough information to call it correctly: it states what it does and the output format. However, it lacks any guidance on when to choose this over the sibling 'google_docs_read', which is a meaningful gap given the tool's simplicity. It does not need to explain return values in detail, but mentioning the differentiation would improve 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 description coverage is 100% — both 'account' and 'documentId' are described in the schema. The description adds no additional meaning beyond what the schema already provides. It does not explain the structure of the returned JSON or any nuances of the parameters, so it does not compensate for or enhance the schema's 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?

The description clearly states the verb 'Get' and the resource 'full Google Docs document', and specifies the output as 'structural JSON'. It is specific enough to convey the tool's function, but it does not differentiate from the sibling 'google_docs_read', which could be a similar read operation. This leaves some ambiguity about which tool to use for different reading needs.

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

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

There is no guidance on when to use this tool versus alternatives like 'google_docs_read'. The description does not mention any context, exclusions, or scenarios where one tool is preferred over another. An agent would have to infer usage from the name and schema alone, which is insufficient.

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

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

No annotations are provided, so the description carries the full burden. It adds useful facts beyond the schema by stating the image must come from a public URI and that an object id is returned, but it does not disclose the mutation/authorization implications of inserting into a document.

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?

A single front-loaded sentence with no filler; the action and its source constraint lead, followed by the return value. Every clause earns its place.

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

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

With full schema coverage and no output schema, the description appropriately covers the source constraint and the returned object id. It stops short of noting access/permission requirements, which would round out a mutation tool lacking annotations.

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 uri, index, account, and documentId in detail. The description adds no parameter-level meaning beyond what the schema provides, so the baseline 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?

States a specific verb and resource ('Insert an inline image') plus the required source ('from a public URI') and the return value. It is clearly distinguishable from google_docs_insert_text and google_docs_insert_table, though it does not name those siblings explicitly to reinforce the difference.

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

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

No when-to-use context, no prerequisites (e.g., that the document must be accessible), and no alternatives are named. The agent must infer from the name alone that this is the image-insertion variant of the docs insertion tools.

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

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

With no annotations provided, the description carries the full disclosure burden. It does surface one genuine side effect ('a newline is added before it'), which is useful for reasoning about index shifts, but a mutation tool of this kind should also say whether the table is styleable afterward, whether existing content indices shift, and what the response contains. The parenthetical is the only behavioral detail offered.

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?

A single tight sentence with the action and the insertion point front-loaded, and the side-effect caveat folded into a parenthetical. No filler, nothing that could be cut without losing information.

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

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

For a 5-parameter write tool with no annotations and no output schema, the description leaves real gaps: permission/auth requirements, behavior on an out-of-range index, whether the newline affects the caller's index arithmetic, and what the result looks like. The newline note is a good start but the surrounding context is thin.

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 rows, columns, index, documentId and account are all documented in the schema, making 3 the baseline. The description's phrase 'model index' loosely restates the schema's '0-based index' rather than clarifying or adding constraint, and it says nothing about the optional account nickname.

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?

Names a specific verb and resource ('Insert an empty table') and adds the insertion-point semantics ('at a model index'), which lets an agent distinguish it from google_docs_insert_text, google_docs_replace_text and google_docs_insert_inline_image. It stops short of explicitly naming those siblings or stating the broader 'in a Google Doc' context, so it's clear but not maximally differentiated.

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

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

There is no guidance on when to reach for this tool versus the other Docs mutation tools (insert_text, replace_text, insert_inline_image, batch_update), no mention of prerequisites such as document write access, and no note on when a batch_update would be preferable for multiple insertions.

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

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

With no annotations provided, the description must carry the behavioral burden. It explicitly states the insertion behavior and the location options, which is adequate for a simple insert operation. However, it does not disclose potential side effects, error behavior for invalid indices, or whether formatting is preserved, which leaves some behavioral ambiguity.

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

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

The description is one clear, front-loaded sentence with no filler. It communicates the core operation, the resource, and the two insertion locations efficiently, earning its place without redundancy.

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

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

For a simple insert tool with fully documented parameters and no output schema, the description provides enough information for an agent to call it correctly: document ID, text, and optional index with a default behavior. It lacks only explicit alternative routing, but that is a usage guideline gap rather than a completeness gap.

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

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

Schema description coverage is 100%, so the schema already fully documents all four parameters. The description essentially restates what the index parameter means ('at an index or at the end'), adding no new semantic detail. The baseline of 3 applies because the schema does the heavy lifting and the description does not conflict.

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

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

The description uses a specific verb ('Insert'), a clear resource ('text into a document'), and a precise location scope ('at an index or at the end'). This clearly differentiates it from siblings like google_docs_replace_text, google_docs_read, and google_docs_create, without needing to open the schema.

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

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

The description states the action but provides no guidance on when to use this tool instead of alternatives such as google_docs_replace_text or google_docs_batch_update, and no conditions or exclusions. The agent is left to infer the appropriate context from the tool name and sibling list.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It does make the read-only nature and plain-text output explicit, but it does not mention whether formatting is stripped, how large documents are handled, or any access-related requirements.

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

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

A single, front-loaded sentence communicates the essential purpose without wasted words. Every part of the description contributes meaning.

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 operation with fully documented parameters, the description is mostly sufficient. However, the lack of any differentiation from google_docs_get and the absence of output-format details beyond 'plain text' leave moderate gaps for an agent selecting among many Google siblings.

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 both documentId and account are already documented in the schema. The description adds no parameter-specific meaning, placing this at the baseline expected when 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?

The description states a specific verb (Read), a clear resource (Google Docs document), and the output form (plain text). It is understandable on its own, but it does not differentiate itself from the sibling google_docs_get, which could plausibly overlap in purpose.

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

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

The description gives only the basic action and no guidance about when to choose this tool over alternatives like google_docs_get or google_docs_batch_update. There are no explicit when-to-use, when-not-to-use, or alternative-routing statements.

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

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

With no annotations provided, the description carries the full burden. It states the operation replaces all occurrences, which is a key behavior, but lacks details like case sensitivity defaults (though matchCase parameter hints at it), effect on formatting, and whether replacement is reversible. It does not contradict annotations since none exist.

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

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

The description is a single concise sentence that immediately conveys the core action and a common use case. It is appropriately front-loaded and contains no unnecessary words, though it could add a bit more context without bloating.

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

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

Given the tool has 5 parameters, 3 required, and no output schema, the description is adequate but not complete. It does not explain the effect of matchCase, the need for an account, or what happens if find text is not present. An agent could call it correctly for simple cases but might be unsure about edge 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?

Schema description coverage is 100%, so the schema already documents each parameter. The description adds minimal semantics beyond the schema, only implying template filling via the parenthetical. That matches the baseline of 3 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?

The description clearly states the verb 'replace' and the resource 'text in a document', and the parenthetical '(template filling)' hints at a common use case. It is distinguishable from siblings like google_docs_insert_text and google_slides_replace_text, though it doesn't explicitly contrast them.

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

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

The description implies usage for template filling, but does not explicitly state when to use this tool versus alternatives like google_docs_batch_update or insert_text. No exclusions or conditions are given, leaving some ambiguity for an agent deciding between tools.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only says 'Copy a file, optionally with a new name.' It does not reveal where the copy is created, whether it overwrites existing files, what permissions are needed, or what side effects occur. This is a minimal statement rather than a transparent one.

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

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

The description is a single short sentence with no filler, and the core action is front-loaded. It earns conciseness points, though it is so terse that it sacrifices useful context.

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

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

The tool is simple and all parameters are documented in the schema, but there is no annotation or output schema to fill gaps. The description omits the copy destination, return value, and any behavioral caveats, making it minimally viable rather than 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 description coverage is 100%, so the baseline is 3. The description adds no real semantic detail beyond the schema; it loosely maps to the 'name' parameter but does not explain the behavior of fileId or account. This is adequate but not additive.

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

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

The description clearly identifies the operation as copying a Drive file, with an optional new name. This is a specific verb and resource, and among the sibling tools it is the only copy operation, so the action is unambiguous. It does not explicitly contrast itself with related tools like upload or update, so it stops short of a 5.

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

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

No guidance is given for when to use this tool versus alternatives such as google_drive_upload or google_drive_update. The description does not state prerequisites, destination behavior, or exclusions, leaving the agent to infer appropriate usage.

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

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

With no annotations, the description must carry the full burden of behavioral disclosure, but it only states the outcome (creates a folder). It does not mention account requirements, default location (root if parentFolderId omitted), potential errors (e.g., duplicate names), or whether the operation is reversible or requires specific permissions. This leaves the agent uninformed about important behavioral aspects.

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

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

The description is a single, concise sentence that directly states the purpose, with no fluff. It is front-loaded with the core action, making it efficient for an agent to parse, though it sacrifices some behavioral detail for brevity.

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

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

For a create operation with a simple schema, the description is minimally adequate, but it lacks important context that an agent might need: it doesn't clarify that the folder is created in the user's Drive (not a shared drive), doesn't mention the default root when parentFolderId is omitted, and doesn't specify whether the account parameter affects where the folder is created. The absence of an output schema also means the description could have mentioned what the response includes (e.g., folder ID), but it doesn't.

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 describes all parameters with clear descriptions (name, account, parentFolderId), achieving 100% schema coverage. The description adds no additional meaning beyond what the schema provides, so the baseline 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?

The description clearly states the action ('create a folder') and the target resource (Drive), which is sufficient to distinguish it from most sibling operations, though it does not explicitly name sibling tools like google_drive_upload or google_drive_update. The verb and resource are specific enough for an agent to understand the core purpose.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as when to use google_drive_upload for files or google_drive_copy for duplicating existing folders. The sibling context implies a clear distinction (folder creation vs. file operations), but the description does not explicitly state exclusions or alternative conditions.

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

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

With no annotations, the description carries the full burden and does well on the biggest risk: it declares the operation IRREVERSIBLE and contrasts it with the recoverable trash path. It stops short of covering permissions/ownership requirements or whether shared users lose access, which would matter for a delete.

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 tight sentences; the destructive nature is front-loaded and the fallback suggestion follows immediately. No filler.

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

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

For a mutation tool with no annotations and no output schema, the description covers the decisive behavioral fact (irreversibility) and the alternative. It could additionally note permission/ownership prerequisites, but nothing critical to a correct call is missing.

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

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

Schema description coverage is 100% and both parameters (fileId, account) are documented inline, so the baseline of 3 applies. The description adds no syntax or format detail about fileId beyond what the schema already states.

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

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

States a specific verb (delete) and resource (file from Drive) with the crucial scope qualifier 'permanently'. It is immediately distinguishable from google_drive_trash in the sibling list.

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

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

Explicitly routes the agent: 'prefer google_drive_trash (recoverable)' names the alternative and the condition (recoverability) that should select it. This is exactly the when-not guidance a destructive tool needs.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not state that this is an irreversible access removal, whether owner/editor privileges are required, what happens to shared-link state, or that the affected user loses access immediately.

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?

A single front-loaded sentence with no filler or redundancy. It is tight, though its brevity is part of why behavioral context is missing.

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

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

For a destructive, unannotated mutation with three parameters and no output schema, the description should say more about consequences, permissions, and failure modes. As written, it is adequate only at the surface 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 description coverage is 100%, with fileId, permissionId, and account all documented in the schema, including the hint that permissionId comes from google_drive_list_permissions. The description adds nothing beyond the schema, 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?

States a specific verb (revoke) and resource (permission on a file) plus the identifier used to target it (permission ID), so an agent can distinguish it from google_drive_share or google_drive_list_permissions. It stops short of explicitly naming a sibling or contrast case, which would be needed for a 5.

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

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

No when-to-use guidance, no prerequisites, and no alternatives named. The agent is left to infer that the permission ID must first be obtained via google_drive_list_permissions, even though that sibling exists in the toolset.

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

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

With no annotations, the description carries the full burden. It does disclose the key behavioral trait of return format (decoded text vs base64) and the response-shape switch when saveToPath is used, but says nothing about authentication/account requirements, file-size or rate limits, or whether saveToPath overwrites an existing local file.

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

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

Three short sentences, each earning its place: scope constraint first, then return-format behavior, then the saveToPath alternative. Front-loaded and free of filler.

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

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

With no output schema, the description compensates by describing the return payload (decoded text vs base64, { savedTo } when saving), which is exactly what an agent needs to interpret the result. Remaining gaps (auth, size limits) are secondary for a read-only byte-fetch 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%, so all three parameters are already documented, including saveToPath's 'returns { savedTo } instead of data'. The description reinforces saveToPath's effect but adds no syntax or format detail beyond the schema; baseline 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?

States a specific verb (Download) and resource (a file's raw bytes), and adds a scope qualifier (non-Google-native files) that implicitly routes Google-native files to the sibling google_drive_export. An agent can distinguish this from google_drive_get and google_drive_export without opening a schema.

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

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

The parenthetical '(non-Google-native files)' acts as an exclusion that tells the agent when this tool applies versus export, and 'Pass saveToPath to write bytes to a local file instead' gives concrete usage guidance for the optional parameter. It stops short of explicitly naming google_drive_export as the 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?

No annotations are provided, so the description carries the full burden. It states the scope (native files only) but does not disclose what the tool returns (file content, URL, etc.), authentication requirements, or potential errors. This is a significant gap for a conversion tool.

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

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

The description is a single, well-structured sentence that front-loads the action and provides concrete examples. 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?

For a tool with no output schema and no annotations, the description is incomplete regarding the return value and operational details. It explains what it does but not the outcome format or any caveats, leaving an agent uncertain about how to handle the result.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value by providing example MIME types (application/pdf, text/plain, etc.) that clarify the mimeType parameter, but it does not elaborate on fileId or account beyond the schema.

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

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

The description clearly states the verb (export), the resource (Google-native file), and the action (converting to another format). It provides specific examples of target MIME types, distinguishing it from related tools like download or get.

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

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

The description implies the use case (converting Google-native files to other formats) but does not explicitly contrast with alternatives such as google_drive_download or google_drive_get, nor does it state when not to use it. It lacks explicit exclusions or sibling references.

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

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

No annotations are provided, so the description carries the full burden. It says 'Get metadata' which implies a read-only operation, but it doesn't disclose what metadata fields are returned, whether the file content is included, or any error conditions (e.g., invalid ID, permissions). For a read tool, this is a moderate gap.

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?

One sentence, front-loaded with the verb and resource, zero waste. It earns its place.

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

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

For a simple get-by-ID tool with 2 params and no output schema, the description is adequate but not complete. It doesn't mention what the response contains (metadata fields) or any caveats like needing the file to be shared with the account. Given no annotations and no output schema, a bit more detail would help.

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 both parameters. The description adds the context that fileId is the target and account is the account nickname, but doesn't add meaning beyond the schema. Baseline 3 is appropriate.

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

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

The description states a specific verb ('Get') and resource ('metadata for a single file by ID'), which clearly distinguishes it from sibling tools like google_drive_download, google_drive_export, or google_drive_delete. It doesn't explicitly name a sibling, but the scope is clear enough to differentiate.

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

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

The description implies usage: use this when you need metadata for a single file by ID. It doesn't explicitly say when not to use it or mention alternatives like google_drive_list for browsing files, but the context is reasonably clear for a simple get-by-ID 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?

No annotations are provided, so the description carries the burden of behavioral disclosure. It discloses ordering ('newest first') and the optional query, which is useful. However, it does not mention pagination behavior, default page size, whether the query syntax is the Drive API query language, or what happens with large result sets. For a read-only list operation, the lack of destructive behavior is implied but not explicitly stated.

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

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

The description is a single, efficient sentence that front-loads the core action ('List files in Drive') and adds the key behavioral detail ('newest first') and the optional query. Every word earns its place; 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?

For a simple list tool with no output schema and no annotations, the description is adequate but not complete. It covers the basic action and ordering, but an agent might need to know pagination behavior, default page size, and how the query parameter interacts with the Drive API. Given the tool's simplicity and 100% schema coverage, a 3 is fair.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters. The description adds the 'newest first' ordering context and the optionality of the query, but it does not add meaning beyond the schema for the parameters themselves. Baseline 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?

The description states a specific verb ('List') and resource ('files in Drive'), and adds ordering ('newest first') and an optional query. It is clear, though it doesn't explicitly differentiate from sibling tools like google_drive_get or google_drive_download; the verb 'list' and the mention of 'files' make the distinction reasonably inferable.

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

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

The description implies usage context: listing files with optional query and default ordering. However, it does not state when to use this tool versus alternatives (e.g., google_drive_get for a single file, google_drive_search if it existed), nor does it mention exclusions or prerequisites like account selection. The 'optional query' hint gives some context but no explicit when-to-use guidance.

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

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

With no annotations, the description carries the full disclosure burden. It implies a read-only listing but never states this, nor does it mention required permissions/scope, what happens for a file with no explicit permissions, or the shape of the returned roles.

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?

A single front-loaded sentence with zero filler, well sized for a simple two-parameter read tool. It is appropriately terse rather than padded.

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 listing tool the description is arguably adequate, but with no output schema and no annotations it leaves the agent guessing about return structure (who/role fields) and read-only safety. Minimum viable rather than 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 description coverage is 100%, so fileId and account are already documented in the schema; baseline is 3. The description adds nothing beyond intent, but nothing is missing either.

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

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

The description states a specific verb (list) and a specific resource (who can access a file and their role), so an agent can clearly distinguish this as a read operation on permission metadata. It does not explicitly name relatives like google_drive_share or google_drive_delete_permission, which keeps it short of a 5.

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

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

There is no guidance on when to use this versus google_drive_get or the share/delete_permission siblings, and no prerequisites such as needing an existing fileId. It only describes what the tool does, not when to reach for it.

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

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

With no annotations, the description carries the full behavioral burden, and it does disclose a genuinely non-obvious Drive trait: omitting removeParentFolderId adds a second parent rather than relocating the file. It stops short of 5 because it says nothing about required edit permissions on source/destination or what happens on failure.

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 tight sentences with the core action front-loaded and the optional-parameter nuance immediately after. No filler, no repetition of the title.

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

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

For a mutation tool with no annotations and no output schema, the description covers the essential semantics an agent needs to pick the right mode. It omits permission/ownership requirements and the shape of the result, which keeps it from being 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%, so the baseline is 3, but the description goes beyond the schema's terse 'Current folder ID to remove the file from (optional)' by explaining the downstream effect of supplying vs omitting the parameter. That is real added meaning.

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

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

States a specific verb+resource ('Move a file into a folder'), which is naturally distinguishable from adjacent siblings like google_drive_copy or google_drive_update. It never names an alternative sibling explicitly, so it stops short of the 5 tier, but an agent can identify the operation without opening the schema.

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

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

Gives clear conditional guidance for the two modes: supply removeParentFolderId for a true move, omit it to add the file to an additional folder. This is actionable context rather than inference. However, it offers no tool-level alternatives (e.g. why not copy+delete) and no prerequisites.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses the mechanism ('sets trashed: false'), but omits permission requirements, what happens if the file is not trashed, and whether the operation is idempotent.

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?

A single short sentence with the operation front-loaded and zero filler. Every clause earns its place.

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

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

For a simple two-parameter restore tool the description is minimally adequate, but with no annotations and no output schema it should say more about permissions and error behavior to be self-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 fileId and account are already documented in the schema. The description adds no parameter-level detail beyond what the schema provides, 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?

States a specific verb and resource ('Restore a trashed file') that clearly identifies the operation. It does not explicitly differentiate from siblings like google_drive_delete or google_gmail_untrash, but the name and title make the scope unambiguous.

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

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

There is no guidance on when to use this versus alternatives such as google_drive_delete or google_drive_trash, nor any stated prerequisites (e.g., the file must currently be trashed). Usage is only implied by the verb.

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

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

No annotations are provided, so the description carries the full behavioral burden. It hints that ownership can be transferred, but does not disclose that transferring ownership typically requires the caller to already be owner, that sharing may be irreversible/security-sensitive, or how notification emails behave - all of which the agent needs for a permission-granting mutation.

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?

A single front-loaded sentence with zero filler; the core action leads and the optional capability trails after a semicolon. Nothing to trim.

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 rich schema (8 params, 100% coverage) and absence of an output schema mean the description need not explain parameters or return values. However, with zero annotations, the behavioral/safety context for a permission-granting mutation is left uncovered, which is the one gap the schema cannot fill.

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 every parameter including enum semantics, email/domain requirements, and the transferOwnership/role=owner dependency is already documented in the schema. The description restates the same concepts (email, link, domain, ownership) without adding format or edge-case detail, so the baseline 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?

States a specific verb (share) and resource (file), and enumerates the three grant modes (user/group by email, anyone with link, domain) that map exactly to the schema's `type` enum. It is distinguishable from siblings like google_drive_list_permissions and google_drive_delete_permission, though it never names them.

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 sentence implies the general context (granting access to a file) but gives no when-to-use guidance, no prerequisites, and no routing to alternatives such as list_permissions or update. Nothing tells the agent when this tool is the wrong choice.

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

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

No annotations exist, so the description must carry the full behavioral burden. It discloses recoverability and the safer alternative, which is the key trait for a mutation. However it omits permission/scope requirements and what happens to files already in trash.

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?

One compact sentence plus a six-word comparison statement. Zero waste and front-loaded with the action and the key safety property.

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 two-parameter mutation with no output schema, recoverability and the safer-alternative routing are the essential disclosures, and both are present. Permission or rate-limit specifics would complete it but the core is there.

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 both parameters documented, so the baseline is 3. The description adds the semantic distinction of the operation, though it does not need to restate fileId semantics.

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

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

States a specific verb and resource ('Move a file to trash'), and the parenthetical names the recovery path. The agent can distinguish it from google_drive_delete without opening sibling schemas.

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

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

Explicitly routes to google_drive_restore as the recovery mechanism and to google_drive_delete as the contrast, matching the 'safer than' guidance. When-to-use is fully implied and the alternative is named.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the operation is a rename/replace, but does not disclose that replacing content overwrites existing data, whether changes are reversible, what permissions or account requirements apply, or what happens when only one field is supplied.

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

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

The description is a single, front-loaded sentence with no filler. Every clause ('Rename', 'replace its content', 'text or local file path') earns its place by mapping directly to supported parameters.

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

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

For a mutation tool with six parameters, no annotations, and no output schema, the description is too thin. It omits usage context, destructive-write warnings, permission expectations, and any behavior beyond the basic rename/replace summary.

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

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

Schema description coverage is 83%, so the schema already documents most parameters. The description adds only a brief gloss on content vs. local file path, while fileId, account, and mimeType remain documented only in the schema. Baseline 3 is appropriate.

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

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

The description names a specific verb and resource ('Rename a file', 'replace its content') and distinguishes the two primary update modes. It is clear what the tool does, though it does not explicitly name sibling tools like google_drive_upload or google_drive_move for contrast.

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

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

There is no explicit when-to-use guidance, no prerequisites, and no comparison to sibling tools. The description implies this is for updating an existing file, but an agent must infer that from the required fileId and cannot tell when to choose this over google_drive_upload, google_drive_move, or other Drive operations.

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

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

With no annotations provided, the description carries the full burden, and it does disclose useful behavior: omitting content yields a blank Google-native file, and the path route reads raw bytes ('binary-safe'). It says nothing about write permissions/scope, overwrite or duplicate-name behavior, what is returned (e.g. file ID for later use), or how parentFolderId affects placement, which are material for a mutation tool.

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

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

A single front-loaded sentence covering the primary action and both optional modes, with no filler. It is dense and slightly parenthetical, but every clause earns its place by distinguishing the two upload paths.

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 6-parameter mutation tool with no annotations and no output schema, the description covers the core modes adequately but leaves gaps: it does not explain the account parameter's role, how parentFolderId interacts with default placement, whether the call requires a specific OAuth scope, or what identifier the agent gets back to use with google_drive_get/update/share.

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, but the description adds real semantics the schema does not: the consequence of omitting content (blank Google-native file) and the binary-safe nature of the path route versus the text-only content route. It does not explain account nicknames or the meaning of parentFolderId beyond the schema's own text.

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

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

States a specific verb and resource ('Create a file in Drive') and clarifies the two creation modes, which separates it from google_drive_create_folder, google_docs_create, and google_sheets_create. It stops short of naming those siblings explicitly, so an agent must still infer which of the Drive/Docs/Sheets creators to pick.

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 sentence implies the two usage modes (text content vs. local path) and when each applies ('binary-safe', 'blank Google-native file if omitted'), which is genuine guidance for parameter choice. However, it gives no when-to-use context relative to the many sibling creation tools (Docs/Sheets/Slides creators, create_folder) and no prerequisites such as account or parent folder 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?

With no annotations provided, the description carries the full behavioral disclosure burden. It only states the action ('Add') and does not describe side effects, whether the operation modifies the form in place, permission requirements, response behavior, or how the tool handles the interplay between type and options. This is a significant gap for a mutation tool.

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

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

The description is a single concise sentence with no filler or repetition. It is straightforward and front-loaded, though it sacrifices behavioral detail for brevity.

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 7 parameters, no annotations, and no output schema, the description is too sparse to fully prepare an agent. It omits behavioral context (e.g., that multiple_choice likely requires options, that required/description are optional modifiers, and what the response/return value is), leaving meaningful gaps.

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

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

Schema description coverage is 100%, so the baseline is 3. The description's mention of 'text or multiple-choice' loosely mirrors the type enum, but adds no meaning beyond what the schema already documents. The parameters' semantics are otherwise handled entirely by the schema.

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

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

The description uses a specific verb ('Add') with a clear resource ('a text or multiple-choice question to a form'), and names the two supported question types. This inherently sets it apart from sibling form tools like google_forms_create, google_forms_get, and google_forms_responses, which clearly perform different actions.

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

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

The description implies its use case (adding a question to an existing form) but never states when to use it versus alternatives, nor mentions prerequisites such as requiring an existing formId. No exclusions or 'when not to use' guidance is provided, so an agent must infer the appropriate context from the tool name and schema.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the action ('create') without revealing side effects, authentication requirements, whether an account parameter is mandatory, what happens on success or failure, or whether the created form is immediately usable. For a mutation tool with zero annotation coverage, this is a significant gap.

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

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

The description is a single, front-loaded sentence with no filler words. It conveys the core purpose efficiently. However, it is somewhat under-specified for a tool with a second optional parameter, and the balance between conciseness and completeness could be improved. Still, it earns a high score for being appropriately sized and non-redundant.

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 this is a creation tool with no output schema and no annotations, the description should clarify at least the return value (e.g., the created form ID) and the role of the optional 'account' parameter. It does neither. An agent would be left unsure how to use the result in subsequent calls (e.g., google_forms_add_question). The description is not complete enough for reliable tool invocation without additional inference.

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

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

Schema description coverage is 100%: both 'title' and 'account' have clear parameter descriptions. The tool description adds only 'with a title,' which reiterates the schema. It does not provide additional meaning about the 'account' parameter (e.g., default behavior, relationship to the 'account' concept). Since the schema already documents parameters adequately, a baseline 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?

The description states a specific verb ('Create') and resource ('a new Google Form') with a required parameter (title). It clearly identifies the tool's function and distinguishes it from siblings like google_forms_get or google_forms_responses by focusing on the creation action. However, it does not explicitly contrast it with other create tools in the suite, so it lacks the explicit differentiation seen in higher-scoring examples.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites (e.g., needing an account), scenarios where this tool is preferred over other form-related tools, or any conditions under which it should not be used. The agent must infer usage context entirely from the tool name and schema.

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

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

With no annotations at all, the description carries the full behavioral burden. It does disclose the most important trait for a destructive operation — permanence/irreversibility — but says nothing about authorization requirements, whether associated responses are also destroyed, or what the call returns on success or failure.

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?

A single four-word sentence with the irreversible nature front-loaded and zero filler. Nothing to trim and nothing buried.

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 permanent destructive tool with no annotations and no output schema, the definition is too thin: it omits recovery options, permission/ownership requirements, and the fate of existing form responses. The fully documented schema offsets this only partially.

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% (formId and account are both documented in the schema), so the baseline of 3 applies. The description adds no extra meaning about either parameter, such as what a form ID looks like or how the account nickname interacts with multi-account setups.

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

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

The description states a specific verb and resource ("delete a form"), which cleanly separates it from the question-level siblings such as google_forms_delete_question. However, it is close to a restatement of the title "Delete form," with "Permanently" being the only added information, so it stops short of the highest tier.

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

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

There is no guidance on when to use this versus alternatives (e.g., no trash/restore path exists here, but nothing says deletion is irreversible-by-design), nor any prerequisites such as required permissions or ownership. The agent is left to infer everything about timing and 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not mention that deletion is irreversible, what permissions are required, or how responses or form structure may be affected. This is a significant gap for a destructive mutation.

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

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

The description is a single front-loaded sentence with no wasted words. It states the action, target, and identifier directly.

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

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

For a destructive operation with no annotations and no output schema, the description should compensate with more context about consequences, permissions, or reversibility. It omits these entirely, leaving the agent with only the bare action.

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 formId, account, and questionId. The description only reiterates that questionId identifies the question to delete, adding no syntax, format, or constraint details beyond the schema.

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

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

The description states a specific verb ('Delete') and resource ('question from a form'), and clarifies the identifier used ('by questionId'). It is clear enough to distinguish from sibling form operations like update_question or move_question, though it does not explicitly name those alternatives.

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

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

There is no guidance on when to use this tool versus related form tools like update_question or move_question, nor any prerequisites or exclusions. The description only states the action, leaving usage context entirely implicit.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Append' usefully implies existing data is preserved, but the description is silent on permissions/auth needs, whether the destination tab is created if missing, rate limits, and how many responses are written. For a write operation with zero annotation coverage this is a significant gap.

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?

A single efficient sentence, front-loaded with the action and destination. No filler, though it is arguably too terse for a write tool rather than padded.

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

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

For a mutation tool with no annotations, no output schema, and four parameters, the description should explain prerequisites, destination-tab behavior, and what the append produces. It covers only the bare action, leaving key operational details unstated.

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 formId, account, sheetName (default Sheet1), and spreadsheetId. The description adds only that rows include headers, which is marginal beyond what the schema supplies. Baseline 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?

States a specific verb ('Append'), resource ('form responses'), and destination ('spreadsheet tab'), with the parenthetical '(headers + rows)' clarifying output shape. It is distinguishable from google_forms_responses (which reads responses) but does not name any sibling explicitly.

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

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

The description gives no when-to-use guidance and does not mention alternatives such as calling google_forms_responses plus google_sheets_append separately. The agent must infer the appropriate scenario entirely from the one-line purpose.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool retrieves structure and questions, implying a non-mutating read operation. However, it does not explicitly confirm the read-only nature, mention auth requirements, or describe edge cases like non-existent forms. For a simple getter this is acceptable but minimal.

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

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

The description is a single sentence with zero filler. The verb and resource are front-loaded, making it immediately scannable. Every word earns its place.

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

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

The tool is simple: 2 parameters, no output schema, and no annotations. The phrase 'structure and questions' gives a sufficient sense of the returned data and differentiates it from response-related siblings. Minor gaps, such as error handling or account behavior, are not critical for a read-only getter.

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 describes both parameters (formId and account) with 100% coverage, so the schema already carries the semantic weight. The description adds no parameter-level detail, so the baseline score 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?

The description states a specific verb, 'Get', and a clear resource, 'a Google Form's structure and questions'. This distinguishes it from sibling tools like google_forms_responses, which retrieves responses, and google_forms_create, which creates forms. An agent can clearly tell what this tool retrieves.

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 implied usage is clear: use when you need a form's structure and questions. However, the description provides no explicit when-not-to-use guidance or alternatives, such as contrasting with google_forms_responses. The context is clear but leaves exclusions to inference.

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

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

No annotations are present, so the description carries the full behavioral burden, yet it discloses nothing beyond the basic action. It does not say whether other questions shift index, whether the move is reversible, what happens on an out-of-range newIndex, or what permissions are needed for a form mutation.

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?

A single compact sentence with the action front-loaded and no filler. It is efficient, though it is perhaps too terse to carry additional needed context.

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?

Parameters are fully covered by the schema and there is no output schema to explain, so the only substantive gap is behavioral (index shifting, ordering side effects, error conditions). For a mutation tool with no annotations, the definition is minimally adequate but leaves that behavioral gap open.

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 formId, questionId, and newIndex are already documented (including the 0-based note and minimum 0). The description adds no parameter-level meaning beyond the schema, so the baseline 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?

States a specific verb (reorder) and resource (a question within a form), clearly distinct from siblings like google_forms_update_question, add_question, and delete_question. It stops short of explicitly naming any alternative, but the resource+action pairing is unambiguous on its own.

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

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

There is no guidance on when to use this versus google_forms_update_question (which might also touch ordering) or how it relates to add/delete. The reordering intent is implied by the verb but no prerequisites or selection conditions are given.

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

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

With no annotations, the description must carry the full behavioral burden. It only states that a title is updated, without mentioning permissions, reversibility, side effects, or the optional account parameter's role. It is a mutation tool with almost no behavioral disclosure.

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

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

The description is a single efficient sentence with no wasted words. It is front-loaded and appropriately sized, though it is minimally informative rather than richly structured.

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

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

For a simple rename mutation with a fully documented schema, the description is minimally adequate. However, it omits usage context, the optional account parameter's effect, and any behavioral traits, and no output schema or annotations compensate.

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

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

Schema description coverage is 100%, so each parameter is already documented in the schema. The description adds no parameter-level meaning beyond what the schema provides, making the baseline score appropriate.

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

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

The description states a clear verb and resource: update a form's title. It distinguishes the form-title scope from sibling tools that update questions or delete forms, but it does not explicitly name or compare against those siblings.

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

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

There is no guidance on when to use this tool versus alternatives such as google_forms_update_question, google_forms_get, or google_forms_delete. No prerequisites, exclusions, or context are provided.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states 'List responses', implying a read operation, but does not mention pagination (pageSize parameter), ordering, or any potential side effects. There is no mention of authentication or account requirements, leaving significant behavioral gaps.

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

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

The description is a single, concise sentence with no fluff. It is appropriately sized for a simple list operation, though it lacks the detail that would make it more useful. It is front-loaded with the core action, which is good.

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