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 implies a state-changing mutation but does not say what 'done' means, whether the operation is idempotent, whether already-completed actions can be re-completed, or what side effects occur.

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 is not bloated, though it is minimal enough to leave significant behavioral gaps scored elsewhere.

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, this description is too sparse. An agent would need to infer idempotency, target-state semantics, and the distinction from update_action; the description alone does not provide enough context for confident invocation.

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

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

Schema description coverage is 0% and the description does not explain that action_id identifies the target action. The parameter name is self-descriptive, but the description adds no meaning beyond the raw schema field.

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

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

The description clearly states a specific operation: marking an action as done. It is unambiguous about the resource and the intended result, but it does not explicitly distinguish itself from the sibling update_action, which could also change an action's 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 gives no guidance on when to use complete_action versus update_action or other action-related siblings. The sibling list implies a CRUD family, but the description leaves the selection entirely 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 provided, so the description carries the full burden of behavioral disclosure. It only says 'Create an action' and does not explain persistence behavior, validation, authorization needs, idempotency, or what the tool returns. For a mutating operation this is a notable gap, though nothing is 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 a single front-loaded sentence that communicates the core purpose, the resource type, and the key optional linkage with no filler. Every word contributes useful 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?

The tool is moderately complex with six parameters, but the schema covers all of them and there is no output schema requiring explanation. However, with no annotations and a very terse description, the agent is left without information about response behavior, failure modes, or constraints such as whether a linked event must already exist. It is adequate for basic invocation but not fully context-complete.

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

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

Schema description coverage is 100%, so the schema already documents all six parameters in sufficient detail. The description adds only the context that actions are tasks/to-dos and can be linked to an event, which maps to event_id, but it does not add meaningful detail beyond the schema.

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

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

The description clearly states a specific verb ('Create'), a distinct resource ('an action (task/to-do)'), and a meaningful qualifier ('that needs to be taken, optionally linked to an event'). It differentiates from create_event by clarifying that actions are tasks/to-dos rather than calendar events.

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

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

The description implies usage by defining what an action is, but it does not explicitly state when to choose this tool over alternatives or when not to use it. The closest sibling alternative, create_event, is only implicitly excluded by the 'action (task/to-do)' framing rather than through explicit routing guidance.

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

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

With no annotations provided, the description carries the full burden of disclosing behavior. It reveals that the tool creates a new event, but does not mention side effects, validation rules, required permissions, conflict handling, idempotency, or what happens on success.

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 zero filler. The parenthetical examples add useful context without bloat, making it appropriately concise 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?

The tool is simple and the schema fully documents parameters and required fields, so an agent can construct a valid call. However, there is no output schema and the description does not explain what the API returns or how to retrieve the newly created event, leaving a notable gap.

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

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

Schema description coverage is 100%, so the schema already documents all six parameters including types and formats. The description adds no parameter-level 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 tool's action ('Create') and resource ('planning event') with helpful examples like meeting, milestone, and deadline. It distinguishes from the sibling create_action by resource type, though it does not 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 when to use the tool — when you need to create a planning event — but provides no explicit guidance about when not to use it or how it compares to create_action. Sibling tool names hint at alternatives, but the description itself does not help route the agent.

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. 'Delete' implies a destructive operation, but there is no mention of irreversibility, permissions, side effects, or error behavior.

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

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

The description is a single direct sentence with no redundant wording, making it structurally concise. However, the brevity reflects under-specification rather than a fully informative definition.

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

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

For a destructive mutation tool with no annotations, no output schema, and only a terse description, the definition is incomplete. It leaves the agent to infer ID usage, permanence, and whether complete_action might be more appropriate for the user's intent.

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 one required string parameter, action_id, with 0% description coverage. The description does not explain action_id's semantics or expected format; it only implies via the operation that an action is being targeted.

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 and resource: 'Delete an action.' It is unambiguous, but it largely restates the tool name and adds no scope or nuance that would set it apart from sibling tools like complete_action or delete_event.

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

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

No guidance is provided about when to use this tool versus alternatives. Sibling tools such as complete_action, get_action, and delete_event exist, but the description gives no context for choosing between them.

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?

Since no annotations are provided, the description carries full behavioral disclosure. It clearly reveals the cascading deletion of associated actions, which is a key side effect beyond the bare operation. It does not mention irreversibility or permissions, but the destructive nature plus the cascade is well covered.

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 front-loads the action and resource, then appends the important cascade side effect. There is no filler, repetition, or unnecessary detail.

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

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

The essential operation and key side effect are stated, but with no output schema and no annotations, the description omits what the call returns and does not clarify irreversibility or permissions. This is adequate for a simple delete tool but leaves notable gaps for an agent making an autonomous call.

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 only parameter, event_id, is minimally described in the schema as a required string. The description adds no parameter-level explanation, format, or constraints. With 0% schema description coverage, the description does not compensate beyond what the property name implies.

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

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

Description uses a specific verb 'Delete' with the resource 'event' and explicitly adds the side effect 'all its associated actions,' which distinguishes it from sibling tools like delete_action. There is no ambiguity about what operation is performed.

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 provided, and no alternatives are mentioned. The sibling tools suggest related operations (e.g., delete_action for action-only deletion), but the description does not route the agent to them, 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 behavioral burden. 'Get' signals a read-only operation and 'full details' indicates the response contains comprehensive action data, but it does not disclose error behavior, authentication needs, or what fields constitute 'full details'.

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 concise sentence that is front-loaded with the verb and resource; every word contributes, with zero filler or redundancy.

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

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

The tool is simple (one required parameter, no output schema), and the description gives the basic get-by-ID contract. However, the absence of any return structure detail or error semantics leaves an agent uncertain about the response shape, especially since no output schema exists.

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

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

Schema description coverage is 0%, so the description must add meaning to action_id. It only says 'by ID', which mostly restates the parameter name and does not explain the ID format, its source, or accepted values.

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 the specific verb 'Get' with the resource 'action' and the qualifier 'single action by ID', clearly distinguishing it from list_actions (plural) and get_event (different resource). It states exactly what the tool does without tautology.

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 phrasing 'single action by ID' provides clear context for when to invoke: when an agent has a specific action_id and needs full details. It implies the distinction from list_actions for bulk retrieval, though it does not explicitly name alternatives or state when-not-to-use.

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 behavioral burden. 'Get' implies a read-only operation, but the description does not disclose potential error behavior, authentication requirements, or what 'full details' means in terms of response content. It is minimally acceptable but not rich.

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

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

A single, front-loaded sentence with zero wasted words. The core action and target 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 simple single-parameter getter, the description provides enough information to invoke it correctly. It could be slightly more explicit about the return payload, but 'full details' reasonably conveys the expected output given the simplicity of the operation.

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

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

Schema coverage is 100%, and the event_id parameter is already described as 'The event ID'. The description's 'by ID' adds no meaningful semantic beyond the schema, hence 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 states a specific verb ('Get'), resource ('event'), and unique scope ('single event by ID'). This clearly distinguishes it from the sibling list_events (which returns collections) and get_action (which targets a different resource).

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 to use this tool: when you need full details of one event. However, it does not explicitly mention alternatives like list_events for multiple events or get_action for actions, so the usage guidance remains implicit rather than explicit.

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

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

No annotations are provided, so the description must carry the full burden. It conveys that the tool returns a summary rather than raw records, but it does not explain what the summary contains, how events and actions are associated, whether any filtering exists, or what the output structure 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?

The description is a single direct sentence with the verb and object front-loaded. There is no wasted wording, though the brevity comes at the cost of usage and behavioral context.

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

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

For a parameterless tool with no output schema, the description names the return concept ('high-level summary of all events and their associated actions') and implies a read operation. However, it lacks detail about what the summary contains, and the absence of annotations leaves the agent with minimal context about behavior or output.

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 schema coverage is 100%, so there are no parameter semantics for the description to add. For a parameterless tool, the baseline is 4.

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 ('high-level summary of all events and their associated actions'). It clearly indicates an aggregated, high-level view that differs from the individual event/action CRUD siblings, though it does not explicitly name a sibling alternative.

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

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

No guidance is given on when to use this tool versus list_events, list_actions, get_event, or get_action. The description implies it is for overviews, but there is no explicit when-to-use or when-not-to-use 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 provided, the description carries the burden of behavioral disclosure. 'List' and the optional filter parameters convey a read-only query operation, but the description does not mention pagination, ordering, access scoping, or return format, leaving some non-obvious behavior unspecified.

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 states the core purpose first and then lists the optional filters. Every word earns its place, and there is no redundant or filler content.

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

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

For a relatively simple list operation with zero required parameters and all parameters documented in the schema, the description is mostly complete. It omits details like return structure and pagination, but the low complexity and clear verb make it sufficiently usable for an agent to select and invoke 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 input schema already fully documents all four parameters. The description adds only a concise summary of the filter dimensions without introducing new semantic information, matching the baseline of 3.

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

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

The description clearly states the operation ('List') and resource ('actions'), and enumerates the available filters (status, assignee, priority, linked event). This distinguishes it from get_action, create_action, update_action, and delete_action, though it does not explicitly name sibling 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?

Usage is implied: use this tool when you need a collection of actions, optionally narrowed by filters. However, it does not explicitly say when to prefer this over alternatives like get_action for a single action or list_events for events, so the guidance remains implicit rather than explicit.

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

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

With no annotations, the description carries the behavioral burden. It correctly communicates that this is a read-only listing operation and that filters are optional, but it does not disclose ordering, pagination, exact match vs substring semantics, or whether date bounds are inclusive.

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 sentence with no filler. The primary action and resource come first, and the optional filtering behavior is stated compactly without redundancy.

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

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

For a simple read-only list tool with no required parameters and no nested objects, the description is sufficient for an agent to understand its basic behavior. Minor gaps like pagination and ordering are relevant but not blocking given the tool's low complexity.

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

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

The input schema already provides 100% coverage with descriptions for tag, after, and before. The description's mention of 'tag or date range' adds no new semantic detail 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 the specific verb 'list', the resource 'events', and the optional filters (tag or date range). This clearly distinguishes it from get_event (single event) and create/update/delete_event (mutations).

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 tool is for retrieving multiple events, and the optional filtering suggests when parameterization is useful. However, it does not explicitly contrast with get_event for fetching a single event or mention any when-not-to-use 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 must carry the behavioral disclosure burden. It only says fields can be changed, but does not disclose that this is a partial update, whether the action must already exist, whether mutations are irreversible, or what the response contains. This is a minimal statement of mutation without meaningful behavioral context.

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

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

The description is a single, front-loaded sentence that immediately names the operation and resource. It is concise and easy to parse, though the 'etc.' is vague and slightly weakens 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?

Given no annotations, no output schema, and the presence of sibling tools like complete_action and delete_action, the description is incomplete. It does not clarify partial update behavior, required identifier, field constraints, or how it relates to complete_action, which are important for an agent to call this tool correctly.

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

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

Schema description coverage is 0%, so the description needed to compensate. It names a few parameters (status, assignee, priority, due date) but omits action_id, title, description, and event_id, and the 'etc.' leaves the full parameter set unclear. It adds little meaning beyond the schema's property names.

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: 'Update an action' with a resource and a list of mutable fields (status, assignee, priority, due date). It is easy to tell this from update_event, but it doesn't explicitly distinguish itself from complete_action, which could be a special case of updating 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?

There is no guidance about when to use this tool versus alternatives like complete_action, and no explanation of partial-update semantics. The description gives no exclusions, prerequisites, or conditions, 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?

No annotations are provided, so the description must carry the full behavioral disclosure burden. It only says fields are updated, but does not reveal whether updates are partial or full, whether omitted fields are preserved, what happens with invalid event IDs, or what the response contains. This is a meaningful transparency gap for a mutation tool.

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

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

The description is a single efficient sentence with no filler or redundant wording. It is concise, though the brevity comes at the cost of missing useful detail.

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

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

The tool has 7 parameters, no output schema, no annotations, and a very short description. It fails to explain key contextual details such as which fields are updatable, whether partial updates are supported, validation behavior, or return values. For the complexity of this tool, the description is incomplete.

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

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

Schema description coverage is 0% and the description does not clarify any parameter meanings, formats, or constraints. Parameter names like title, start_time, and tags are somewhat self-explanatory, but time formats, allowed values, and update semantics for each field are left entirely unspecified.

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 ('Update'), a clear resource ('event'), and scopes it to an existing event. This distinguishes it from sibling tools like create_event, get_event, list_events, and delete_event without ambiguity.

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

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

The description gives clear context: it is for modifying an existing event rather than creating, retrieving, listing, or deleting one. It does not explicitly name alternatives or exclusion cases, but the wording is sufficient for an agent to select it appropriately.

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