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 the full behavioral burden, and it does disclose one genuinely valuable failure mode: an unreadable calendar surfaces errors rather than appearing free, which prevents false 'available' conclusions. It leaves out whether the call is strictly read-only, permission/auth expectations, and what the response shape looks like.

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 sentences, zero filler, with the core purpose front-loaded and the caveat about partial failures placed immediately after. Every clause carries 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 read tool with full schema coverage and no output schema, the description covers purpose and the key error behavior. It could go slightly further in describing the returned busy-interval structure or timezone/range edge cases, but nothing critical for correct invocation 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%, so all five parameters (items, account, timeMin, timeMax, timeZone) are already documented in the schema. The description adds no parameter-level meaning beyond that, which is the expected baseline when the schema does the work.

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 ('Query busy intervals across calendars') and adds the practical intent ('find free meeting windows'), which distinguishes it from google_calendar_list_events at a conceptual level. It never names that sibling explicitly, so differentiation relies on the agent inferring the busy-vs-detailed-events 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?

The phrase 'to find free meeting windows' implies the usage context, but there is no explicit when-to-use/when-not guidance and no mention of alternatives such as google_calendar_list_events for event details. Usage must be inferred from the purpose sentence.

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?

With no annotations, the description carries the full burden but only discloses access scoping ('the account can access'). It omits pagination behavior despite a pageToken parameter, whether the primary calendar is included, ordering, and any read-only/safety context. This is thin for an unannotated 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 zero wasted words. It states purpose and scope immediately.

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 read tool with full schema coverage, the description covers the core action. However, it lacks pagination guidance and any behavioral context that would be needed in the absence of annotations, leaving it minimally adequate.

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

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

Schema description coverage is 100%, so both parameters (account, pageToken) are already documented in the schema. The description adds no parameter-level meaning beyond what structured data provides, which is the baseline for full 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?

States a specific verb (List) and resource (calendars) with the scope 'the account can access,' which inherently distinguishes it from sibling tools like google_calendar_list_events. It does not explicitly call out the sibling comparison, but the resource noun is unambiguous.

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

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

No guidance on when to use this tool versus alternatives (e.g., list_events, free_busy) or what prerequisites exist. The scope clause hints at account filtering but does not say when the tool should be selected.

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 behavioral burden. 'List' implies read-only and non-destructive, which is useful, but it omits pagination behavior (despite pageToken/nextPageToken in the schema), the default result cap of 25, and how recurring events or 'upcoming' are resolved.

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. It is appropriately sized for the message it delivers, though that brevity leaves the other useful details (paging, defaults, account scope) unaddressed.

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?

Seven parameters, no annotations, and no output schema mean the description should do more work. It never explains pagination (pageToken fields exist), the default 25/250 limits, the account-vs-calendarId relationship, or what an event record looks like on return.

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 seven parameters are already documented inline (q, account, timeMin/timeMax, pageToken, calendarId, maxResults). The description only restates the time-range and query filters, adding no meaning beyond the schema, 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 verb and resource ('List upcoming events in a calendar') plus the optional filtering dimension. It's clear enough to distinguish from get_event or create_event, but never names those siblings or clarifies how it differs from google_calendar_free_busy or google_calendar_list_calendars.

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 by 'List upcoming events' and 'optionally filtered'. There is no explicit when-to-use guidance, no exclusions (e.g. use get_event for a single event, free_busy for availability), and no mention of prerequisites like which account is used.

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

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

No annotations are provided, so the description carries the full disclosure burden. It does add real behavioral context — that the response is recorded against an attendee already on the invite — but says nothing about notification side effects (the sendUpdates default of 'none'), permission requirements, or whether the organizer can respond for others.

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 sentences, zero waste, with the action and the hard precondition front-loaded. Nothing is redundant with 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?

With six parameters, no annotations, and no output schema, the description is on the thin side. It covers the core action and one failure mode, but omits notification behavior and the fact that responses can be set for other attendees via the email parameter — both relevant to calling 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?

Schema description coverage is 100%, so the baseline is 3. The description adds only marginal meaning, tying 'responseStatus' to attendance and constraining 'email' to an existing invitee; the other four parameters 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 set (accept, decline, mark tentative) and a specific resource (an event invite's attendee responseStatus), so the agent knows exactly what the operation does. It does not name or differentiate from the closest sibling, google_calendar_update_event, which could also plausibly touch attendance state.

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 'The address must already be on the invite' is a genuine precondition that tells the agent when this call will fail. However, there is no explicit guidance on when to use this versus google_calendar_update_event, and no statement about whether the caller must be an attendee.

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 burden and delivers almost nothing: it doesn't say that attendee updates replace the whole list, that changes may trigger notification emails (sendUpdates), whether changes apply to recurring instances, or whether the operation is reversible. The only behavioral disclosure is the '(partial update)' note.

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 repetition. It is efficient, though its brevity is partly under-specification rather than true density.

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 17-parameter mutation tool with zero annotations and no output schema, one sentence is not enough: risks of overwriting attendees/recurrence, notification side effects, and account/calendar scoping all go unaddressed. Only the schema carries the 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%, so the schema already documents nearly all 17 parameters, including the subtle start/end duration behavior and enum meanings. The description adds no parameter meaning of its own, 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 ('Update fields of an existing event') and clarifies the partial-update semantics, which is a meaningful distinction. It doesn't differentiate from nearby siblings like google_calendar_update or google_calendar_create_event, 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 when-to-use guidance, no prerequisites (eventId required, calendarId defaulting to primary), and no mention of when to prefer this over google_calendar_update or how it relates to google_calendar_get_event. '(partial update)' is the only usage hint and it is inferred rather than 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?

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?

No annotations are provided, so the description carries the full disclosure burden. 'List' implies a read-only operation, but there is no mention of pagination limits, ordering, permission scoping, or how nextPageToken results behave — the schema mentions the token but the description does not explain the paging loop an agent must run.

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 with no filler, and the core resource is front-loaded. It is appropriately sized, though the space saved could have been spent on paging or sibling differentiation.

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 3-optional-parameter read tool with full schema coverage and no output schema, the description minimally suffices and usefully hints at returned fields. However, it omits result paging behavior (nextPageToken) and how many records come back by default, which matter in practice.

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 account, pageSize, and pageToken are already documented in structured data. The description adds no meaning beyond the schema and does not clarify default account behavior when 'account' is omitted — 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 (list contacts) plus the fields returned (names, emails, phones). It does not explicitly differentiate from the sibling google_contacts_search or google_contacts_get, so an agent must infer the distinction from the name alone.

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 indication of when to prefer this over google_contacts_search or google_contacts_get, and no guidance on paging through results. It says nothing about when NOT to use it or what prerequisites (account selection/default) apply.

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

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

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, so the description carries the full burden. It does disclose one genuinely useful behavior — multi-valued fields keep their other entries, i.e. partial/additive semantics — but never says what happens to fields not supplied (cleared vs. preserved), whether the operation is reversible, or what auth/permissions are needed.

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 sentences, no waste, with the mutable-field scope front-loaded before the behavioral caveat. 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 an 8-parameter mutation tool with no annotations and no output schema, the description covers which fields can change but omits the key open questions: partial vs. full replacement for omitted fields, failure behavior for an invalid resourceName, and confirmation of what is returned.

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

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

Schema coverage is 88%, so the schema already documents name, email, phone, account, address, photoBytes, organization, and resourceName. The description only echoes the field list and adds the multi-valued retention nuance, which is marginal value on top of an already well-documented 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 ('a contact's') and enumerates the mutable fields, so the agent can tell it apart from google_contacts_create, google_contacts_get, and google_contacts_delete. It does not explicitly name those siblings, but the operation is unambiguous.

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

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

No guidance on when to use this versus google_contacts_create or google_contacts_search, and no mention that resourceName must come from a prior list/search call (that hint lives only in the schema). Usage is only implied by the word 'update'.

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. It implies a destructive mutation but says nothing about irreversibility, permission requirements, or how document indices shift after a deletion, which is the single most important behavioral fact for a range-delete 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?

One front-loaded sentence with no filler. It is efficient, though its brevity comes partly from omitting behavior an agent needs rather than from disciplined editing.

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?

This is a destructive mutation tool with no annotations and no output schema. The description should warn about index invalidation after deletion and about the operation being irreversible, and it covers neither.

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 that startIndex is 1-based inclusive and endIndex is 1-based exclusive. The description adds nothing beyond that, 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 ('Delete') and a specific resource ('a range of content from a document'), so an agent knows exactly what the tool does. It does not distinguish itself from siblings that can also remove content, such as google_docs_batch_update or google_docs_replace_text.

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_docs_batch_update or google_docs_replace_text, and no statement of prerequisites. Usage is only implied by the verb 'delete'.

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 behavioral disclosure burden. It implies a mutation by saying 'insert' and mentions the returned object id, but it does not state permission requirements, reversibility, failure behavior, or rate limits for a write operation.

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 definition is a single front-loaded sentence with no wasted words. It states the action, source, and return value efficiently.

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

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

The description covers the essential action and return value, and the schema fully documents parameters. However, for a mutation tool with no annotations, it should say more about operational context such as authentication needs or constraints on insertion position.

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 four parameters are already documented. The description adds little beyond the schema: it implies URI source and object-id return, but does not clarify index placement or account selection semantics beyond what the schema provides.

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

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

The description names a specific verb and resource: insert an inline image. It also specifies the source (public URI) and return value (created object id). It is clearly distinguishable from google_docs_insert_text and google_docs_insert_table, 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 gives no explicit guidance on when to use this tool versus alternatives such as google_slides_create_image or google_docs_insert_text. It also omits prerequisites, like whether the document must already exist or the index must fall inside an existing paragraph.

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 that the inserted table is empty and that a newline is added before it, but it does not mention write permissions, what happens to existing content at the index, failure behavior, or the response shape.

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 text. The parenthetical side-effect note is compact and useful.

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 too thin. It explains the core insert action but omits permission requirements, return behavior, and error or edge-case context an agent would need before invoking it.

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 all five parameters, so the baseline is 3. The description does not add parameter-level meaning beyond the schema, such as index constraints or account behavior.

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: insert an empty table. The word 'table' distinguishes it from sibling tools like google_docs_insert_text and google_docs_insert_inline_image, though the phrase 'model index' is somewhat ambiguous and 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 tool versus alternatives such as google_docs_insert_text or google_docs_batch_update, and no stated preconditions. Usage is only implied by the 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?

No annotations are provided, so the description carries the full behavioral-disclosure burden. 'Insert' implies a write operation, but the description omits edit-permission requirements, effects on existing content or index shifting, and return behavior; only the default end-of-document location is 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?

A single front-loaded sentence with no redundancy, efficiently stating the action and insertion location.

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 operation with fully documented parameters, the description covers the action and target location. However, with no annotations and no output schema, it leaves mutation side effects, permissions, and response behavior undisclosed.

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 four parameters. The description echoes the index-or-end behavior already present in the schema and adds no further format or constraint details.

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 (insert) and resource (text into a document), plus the insertion location (index or end). This distinguishes it from replace_text and insert_table by operation, but it does not explicitly route among the docs-editing siblings.

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

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

The description provides no when-to-use guidance, prerequisites, or alternatives. An agent must infer from sibling tools whether to use this versus google_docs_replace_text or google_docs_batch_update.

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, and it does add real value by specifying the conditional return shape (decoded text vs. base64). However, it omits what happens when the file IS Google-native (error? empty?), whether saveToPath overwrites an existing file, and any size/permission constraints on large binaries.

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, front-loaded with the core action and scope, then the return-variant rule, then the optional output destination. Nothing is padded and each clause adds distinct 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 3-parameter tool with no output schema and no annotations, the description covers the primary return shapes but leaves the Google-native edge case, overwrite behavior, and size limits unstated. Adequate to invoke on the happy path, thin on failure modes.

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 fileId, account and saveToPath are already fully documented, including the save-root restriction. The description restates saveToPath's effect without adding constraints beyond the schema, 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 (download) and resource (a file's raw bytes), and narrows the scope with '(non-Google-native files)'. That scope carve-out implicitly separates it from google_drive_export, but the sibling is never named, so the agent must infer the boundary.

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 '(non-Google-native files)' parenthetical implies that Google-native docs belong elsewhere, and the saveToPath sentence gives one usage pattern, but neither is framed as an explicit when-to-use rule. There is no routing to google_drive_export for Docs/Sheets/Slides and no guidance on when returning bytes vs. writing to disk is preferred.

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 behavioral load. It discloses the destination behavior and mentions the { savedTo } return shape, but says nothing about auth requirements, the roughly 10MB Drive export size limit, whether the source file is modified, or error behavior on unsupported MIME conversions.

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 sentences, zero padding, with the capability and its file-type scope front-loaded before the optional output-routing behavior. Every sentence carries 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 4-param tool with full schema coverage and no output schema, the description covers what it does, what it accepts, and the two output modes. It falls short only on operational limits and MIME-compatibility caveats that an agent might need to avoid failed calls.

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

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

Schema coverage is 100%, so the schema already documents all four parameters including the save-root constraint. The description only restates mimeType examples and saveToPath's purpose, adding no format rules or validation 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?

States a specific verb+resource with an explicit scope restriction (Google-native Docs/Sheets/Slides/Drawings only), which effectively separates it from google_drive_download for binary files. It does not name the sibling outright, so the differentiation is inferred rather than declared.

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 applicability context: only Google-native files can be exported, and passing saveToPath switches from returning bytes to writing a local file. No explicit when-not-to-use or named alternative (e.g. 'for non-native binary files use google_drive_download') is 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?

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?

With no annotations at all, the description carries the full burden, and it does disclose the default sort order ('newest first') — genuine behavioral context. It omits what a result contains, how pagination behaves beyond the schema's own pageToken/pageSize fields, and what happens with no query (full listing, presumably). Useful but incomplete for an unannotated 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?

One short sentence with the resource and the default ordering front-loaded and zero filler. Nothing could be removed without losing 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?

A 4-parameter listing tool with no annotations and no output schema leaves the agent guessing at what a returned file record looks like and how to page through large result sets. The schema covers parameter syntax well, but the description does nothing to fill the behavioral and return-shape 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% and every parameter is documented there, including the query example, account nickname, page size default, and page token usage. The description adds only that the query is optional, 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 and resource ('List files in Drive') plus a default ordering ('newest first'), which is enough to distinguish it from google_drive_get, google_drive_export, and the many write-side Drive siblings. It stops short of naming a specific alternative, but the operation is unambiguous.

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

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

It says what the tool does but never when to choose it over google_drive_get (single file) or google_drive_export (export to another format). There are no prerequisites, no exclusions, and no mention of how a query narrows results versus listing everything.

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 at all, the description carries the full behavioral burden, yet it says nothing about required write permissions, whether the form must be unpublished, whether the append is reversible, or what identifier is returned. Only the positional behavior (append at end) 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 economical sentence with the key action and placement constraint front-loaded and zero 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 7-parameter mutation tool with no annotations and no output schema, the description omits what matters most operationally: what is returned (e.g., a question ID needed for later update/move/delete) and any preconditions. It is too thin for the tool's complexity.

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

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

Schema coverage is 100%, so every parameter is already documented in the schema; the description adds only the 'text or multiple-choice' type hint, which restates the enum. Parameters such as options, required, description, and account are left entirely to the schema, which is acceptable given full 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 names a specific verb (append) and resource (question) and gives positional scope (end of a form). It stops short of distinguishing append from the sibling google_forms_update_question or google_forms_move_question, so an agent must infer the difference from the names alone.

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 reference to alternatives like update_question, move_question, or delete_question. The only implicit cue is the word 'append', which hints at position but not at tool 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?

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?

With no annotations, the description carries the full load and does a solid job: it discloses deduplication semantics, row migration by answer matching, placement of newly added questions, and a failure mode (reordered columns fail safely). It omits permission/scope requirements and whether the destination sheet must already exist, which keeps it below a 5.

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 dense sentences with zero filler, front-loaded with the core action and then the non-obvious migration semantics. Every clause carries information an agent would otherwise have to discover at runtime.

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 4-parameter mutation with no output schema, the description covers the hard parts (dedup, migration, failure mode) but leaves open whether the tab is created when absent and what an export returns (row counts, new vs. migrated). Those gaps are minor given the otherwise rich behavioral 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 100%, so formId, account, sheetName and spreadsheetId are already documented in the schema. The description's mention of the ID column and column ordering adds context about write behavior but nothing about parameter formats or the default tab behavior. 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 opens with a specific verb+resource pair ("Append form responses to Sheets") and adds a distinctive implementation detail (a __google_forms_response_id column). An agent can distinguish it from google_forms_responses (read) and google_sheets_append, though it never names those siblings 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 explicit when-to-use statement or named alternative. Usage is only implied through behavior: the dedup column and row migration tell an agent that repeated exports are safe, but nothing says when to call google_forms_responses instead or what preconditions exist.

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.