aitrips.io

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds that it returns 'full details' but does not mention output shape, error cases, or whether 'full details' varies by type. With annotations covering the read-only nature, a 3 is fair — the description adds some but not rich 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?

Single sentence, zero wasted words, and the essential parameters are front-loaded. It is concise and readable.

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 2-parameter read-only fetch tool with full schema coverage and a readOnly annotation, the description is complete enough. It does not explain why type is needed or how the result is structured, but those are minor given the schema and the absence of an output schema requirement.

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 are already documented. The description only restates the idea of 'ID and type' without adding info beyond the schema. Baseline 3 is appropriate because the schema carries the load.

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 ('Fetch') and resource ('full details for a search result by ID and type'). It clearly distinguishes itself from the search tool by operating on search results, and from trip_get/trip_item_list etc. by requiring both id and type. This is a clear, differentiated 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 phrase 'for a search result' implies this tool is meant to be used after search, and the presence of sibling 'search' indicates the workflow. It does not explicitly name alternatives or exclusions, but the id+type pair and the mention of search results provide clear contextual guidance. Slight deduction for not explicitly saying 'use this after search, not for direct IDs'.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds that results are 'indexed results' and tied to Deep Research mode, which is useful but does not disclose limitations like pagination or relevance 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 two short sentences with no filler. The main scope is front-loaded, and the second sentence adds meaningful behavioral context about the return mode.

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 one-parameter read-only search tool, the description covers the entity scope and the output mode adequately. The lack of an output schema leaves the exact result shape underspecified, but this is a minor gap for a search 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 description coverage is 100% for the single query parameter, so the schema already documents it. The description adds the cross-entity scope but does not explain the query syntax or expected format 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 action, 'Search,' and a clear resource scope: 'across trips, items, and locations.' This distinguishes it from sibling tools like fetch and trip_* list operations, and the mention of 'Deep Research mode' further clarifies its specialized role.

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 makes the primary use case explicit: searching across multiple entity types and retrieving indexed results for Deep Research mode. It does not explicitly state when to prefer fetch or trip_* alternatives, but the scope is clear enough to guide selection.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the 'Get' verb is consistent with those. The description adds modest behavioral context by revealing the log's semantic content ('who changed what, when'), but it does not disclose ordering, pagination behavior, or whether caller collaborator permissions are required — so the added value beyond annotations is limited.

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 zero waste: the verb and resource appear first, and the em-dash clause adds valuable detail about the log's contents. Every element 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 read-only list tool with a fully covered schema and safety annotations, this is largely complete: required and optional parameters are documented, and the description clarifies what the log contains. The only real gap is the absence of any return-shape or ordering hint, which is minor given there is no output schema and the tool's purpose is simple.

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

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

Schema description coverage is 100%, so all three parameters (tripId, limit with default 50, entityType with a full enum) are already fully documented in the schema. The description adds no parameter-level meaning beyond what the schema provides, so the baseline 3 applies.

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

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

The description names a specific resource ('activity log for a trip') with a clear verb ('Get') and defines what the log contains: 'who changed what, when.' This meaningfully distinguishes it from all siblings — none of the other trip_* tools claim to return change history, so an agent can select it confidently.

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 a use case (auditing what changed on a trip) but never states when to use this tool versus an alternative, and no sibling is named as a fallback. The context is clear enough to infer intent, but explicit routing guidance is absent.

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

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

Annotations already signal this is a mutating but non-destructive operation. The description adds useful behavior context by saying dates shift relative to the new start date, but it does not explicitly state that the original trip is left unchanged or what happens to entity relationships beyond a broad 'all its data' claim.

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 carry the core purpose and the key behavioral nuance. There is no filler, and the most important information is front-loaded.

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

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

For an 8-parameter mutating tool with no output schema, the description is adequate but leaves gaps: it does not describe what a successful clone returns, whether the source trip remains untouched, or how the optional include flags relate to the 'all its data' claim. Schema and annotations fill some gaps but not these.

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 parameters are already well documented. The description restates the date-shift concept already present in the startDate parameter and offers little additional semantic value 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 ('Clone/duplicate') with a clear object ('a trip') and scope ('with all its data'). This clearly distinguishes it from trip_create, trip_update, and other trip operations 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?

The description gives clear context: use this when duplicating an existing trip and its data. It does not explicitly name alternatives or exclusions, such as 'use trip_create for a blank trip', but the use case is unambiguous enough for an agent to route correctly.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds the useful qualifier 'all', implying the full collaborator set is returned, but provides no additional context about response shape, pagination, or permissions.

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 filler. Every word contributes to the tool's purpose, and the key action and resource are 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 one-parameter read-only tool, the description is nearly complete: it names the resource, the action, and the scope ('all'). It does not detail the return value, but the read-only annotation and the simplicity of the tool keep this from being a significant 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%, with tripId documented as 'Trip ID'. The description only mentions 'for a trip' and adds no extra meaning beyond what the schema already provides, so the baseline 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 uses a specific verb ('List') and a clear resource ('collaborators for a trip'), making the tool's purpose immediately recognizable. It is distinct from sibling tools like trip_collaborators_remove and trip_share_list, even without explicitly naming 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 states what the tool does but gives no guidance on when to choose it over alternatives, no exclusions, and no mention of related tools such as trip_collaborators_remove. An agent must infer usage context from the tool name and siblings.

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

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

Annotations already declare destructiveHint=true, so the destructive nature is covered without needing the description to repeat it. The description adds useful context by restricting the action to the trip owner, but it does not disclose effects like reversibility, immediate access revocation, or whether the owner can be removed.

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 with no filler. It conveys the action, target, and an important access-control constraint 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?

For a simple two-parameter destructive operation, the description plus schema and annotations cover the essential facts: what happens, which parameters are needed, and who is allowed to call it. It lacks edge-case details like owner self-removal or post-removal behavior, but these are not critical for basic tool selection and invocation.

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

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

Schema description coverage is 100%, with both tripId and collaboratorUserId documented. The description adds no additional parameter-specific meaning beyond the owner restriction, 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 uses a specific verb ('remove') and resource ('collaborator from a trip'), making the operation clear. It does not explicitly distinguish itself from sibling tools like trip_share_revoke, but the collaborator framing separates it from list/share operations reasonably well.

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 'owner only' qualifier gives a clear authorization context for when this tool can be invoked. However, it does not state when to prefer this over alternatives such as trip_collaborators_list or trip_share_revoke, nor does it describe what not to use it for.

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

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

The annotations already declare readOnlyHint=false and destructiveHint=false, so the description adds nothing beyond what structured data conveys. It discloses no behavioral traits such as whether duplicate names are rejected, whether the trip is created empty, or what the response contains. The description is consistent with the annotations but provides no additional 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 four-word description is technically lean with no wasted words, but it is concise at the expense of substance — every word essentially restates the tool name. As a 'minimally viable' description it earns a 3, but there is ample room to add usage or workflow context without risking bloat.

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 create operation with no output schema, this description is thin. It does not explain what happens after creation, how the response should be used, or how this tool fits into the broader trip workflow among 34 siblings. An agent has no context that creating a trip is likely the first step before adding items, activities, or collaborators.

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 fully documents all 7 parameters including formats (YYYY-MM-DD), defaults (USD, UTC), and examples. Per the rubric baseline, a 3 is appropriate when the schema carries the parameter documentation burden. The description itself contributes no parameter information, but none is needed given complete 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 and resource ('Create a new trip') that clearly states the operation, matching the tool name and annotation title. It is distinguishable from nearby siblings like trip_update (modify existing), trip_get (read), and trip_item_add (add to a trip). However, it does not explicitly differentiate itself from trip_clone, which also produces a new trip.

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 zero guidance on when to use this tool versus alternatives. An agent cannot tell whether creating a trip is a required prerequisite for trip_item_add or trip_task_create, nor when trip_clone would be the better choice for generating a trip. No context, prerequisites, or exclusions 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?

Annotations already provide destructiveHint=true and readOnlyHint=false. The description adds meaningful context beyond annotations by stating that deletion removes 'all associated data', signaling a cascading destructive effect. This is valuable behavioral information for an agent deciding whether to proceed.

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, tightly worded sentence that front-loads the action and scope. Every word earns its place, with no redundant filler or restatement of schema details.

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

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

For a simple two-parameter destructive tool, the description is nearly complete: it states the action, the scope, and the confirm parameter is documented in the schema. It does not describe return behavior, but the lack of an output schema and the presence of strong destructive annotations keep this gap minor.

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 tripId and confirm already documented. The description does not need to repeat parameter details and adds no additional parameter-level meaning, so the baseline 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 ('Delete') and resource ('a trip'), and 'all associated data' clarifies scope beyond the name. This clearly distinguishes it from trip_item_delete and other resource-specific delete tools among the 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 context is clear: this tool is for deleting an entire trip, not a sub-resource like an item, note, or task. It does not explicitly name alternatives, but the combination of name, description, and sibling list makes the appropriate use apparent.

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

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

The readOnlyHint and destructiveHint annotations already cover the side-effect profile. The description adds that the result includes items, locations, and itinerary, but does not disclose other behavioral aspects such as auth requirements, pagination, error behavior, or whether the returned data is scoped to the requesting user.

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 purpose and adds useful detail about what the trip details include. There is no wasted wording 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 read-only tool with one required parameter and no output schema, the description provides enough context by naming the returned content areas. It could be slightly stronger by explicitly noting it returns a single trip object matching the provided tripId, but it is largely complete for this complexity level.

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

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

Schema description coverage is 100% for the only parameter, tripId, with the description 'Trip ID'. The tool description adds no parameter-specific meaning, so the baseline of 3 applies because the schema fully documents the parameter.

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

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

The description states a specific action and resource: 'Get trip details' and lists the key content ('items, locations, and itinerary'). It clearly distinguishes this from trip_list and other trip-related tools by focusing on a single trip's detailed 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 for when to use this tool versus alternatives like trip_list or fetch. The tool name implies the use case, but the description does not state conditions, exclusions, or when a different tool would be more 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?

The annotations only provide readOnlyHint=false and destructiveHint=false, so the description adds value by indicating an additive insert operation and listing supported item types. However, it does not describe the return value, duplicate behavior, or any side effects, leaving part of the behavioral burden uncovered.

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. It immediately communicates the verb, object, and scope, and every word contributes to 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?

This is an 18-parameter create operation with no output schema, yet the description does not explain what the tool returns, such as the created item object or ID. It also fails to address the obvious overlap with trip_transport_add, making the definition incomplete for an agent deciding between similar tools.

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 already has a description, default, or enum. The description's listed item categories roughly mirror the 'type' enum and do not add significant meaning beyond what the schema already 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 ('Add an item to a trip') and lists representative item categories, so an agent can understand the core purpose. However, it does not distinguish this from the sibling trip_transport_add, which also appears to cover adding transport-related items.

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. The sibling set includes trip_transport_add, trip_note_create, trip_location_add, and trip_task_create, and the description does not explain which cases belong to trip_item_add or what this tool is NOT for.

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

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

Annotations already indicate readOnlyHint=false and destructiveHint=false, so the description adds the mention syntax ('Use @name to mention collaborators'). It does not disclose whether this mutates existing data, requires editing rights to the trip item, or whether mentions are resolved from the mentions array or parsed from content. No contradiction with annotations.

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

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

Two sentences with no wasted words, front-loaded with the core action. The @mention guidance earns its place, though the description is brief.

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 create-like mutation with no output schema, it covers the core action and mention behavior. It does not explain whether the third optional mentions parameter is required when using @name, nor the response behavior, which are minor 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 coverage is 100% and includes descriptions for itemId, content, and mentions. The description adds the @name mention syntax context, but this is minor since the schema already says content supports @mentions. It does not explain how mentions relates to content mentions.

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 ('Add a comment to a trip item') and mentions @mentions, which distinguishes it from listing comments (trip_item_comment_list). It does not explicitly name the sibling alternative, but the resource and action are clear.

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 it—when a comment needs to be added to a trip item—and gives formatting guidance for mentions. It does not explicitly contrast with sibling tools like trip_item_comment_list or discuss prerequisites such as permission to comment.

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

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

The annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is known. The description adds no behavioral context beyond restating the operation, such as pagination, ordering, or what happens when the item does not 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 short sentence with zero wasted words. It is front-loaded with the action and resource, making it easy 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, read-only listing tool with one well-documented parameter and no complex output schema, the description is mostly sufficient. It does not mention return format or possible empty results, but those are minor for this straightforward 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 description coverage is 100% and the only parameter, itemId, is already described as 'Trip item ID'. The description does not add further meaning, which is acceptable because the schema fully covers the parameter.

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

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

The description uses a specific verb ('List') with a clear resource ('comments on a trip item'), making the tool's purpose immediately obvious. It also distinguishes itself from the sibling trip_item_comment_add, which is the write counterpart.

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 exclusions, prerequisites, or relationships to sibling tools like trip_item_comment_add or trip_item_vote.

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

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

The annotations already flag readOnlyHint=false and destructiveHint=true, and the description adds no behavioral detail beyond those flags. It does not mention permanence, side effects on associated data, or permissions, so the description itself contributes little transparency.

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 short, direct, and front-loaded with the action. It uses no filler words, though its brevity also leaves the behavioral and usage context to the annotations and schema.

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

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

For a single-parameter delete operation with destructive annotations, the description is minimally adequate: it names the resource and the schema identifies the required ID. However, it lacks explicit detail on irreversibility or what happens to related data, and the absence of an output schema means return behavior is not described.

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

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

Schema description coverage is 100%: itemId is present and described as 'Item ID.' The description adds no additional meaning about the parameter, so the baseline score of 3 applies because the schema already documents what the agent needs.

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

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

The description states a clear verb and resource: 'Delete a trip item.' It is unambiguous about what the tool does and distinguishes it from trip-level tools like trip_delete, though it is minimal and does not explicitly contrast with related item-specific delete 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?

There is no guidance about when to use this tool versus alternatives such as trip_item_update, trip_location_delete, or trip_delete. No context is provided for prerequisite steps like obtaining itemId from trip_item_list, so an agent must infer usage 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?

The readOnlyHint and destructiveHint annotations already establish that this is a safe read operation, and the description adds no behavior beyond what the schema already shows ('optional filters' is visible in the parameters). It does not disclose sorting, pagination, default filter behavior, or what the list returns, so no meaningful behavioral context is added beyond the structured fields.

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 resource and action come first, and 'optional filters' is the only additional context. Every word eins its place, and there is no redundant prose.

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

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

The description is minimally viable for a safe, read-only list operation with fully documented parameters, but gaps remain: there is no output schema to describe the returned item shape, no mention of ordering/pagination, and the description doesn't disambiguate 'items' from the closely related sibling list tools. It is adequate but not 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 input schema covers 100% of parameters with descriptions and enums, so the schema carries the semantic burden. The description only restates 'optional filters' generically and adds no parameteer-level meaning beyond the schema; therefore it meets the high-coverage baseline but does not exceed it.

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 clear action ('List') on a specific resource ('items for a trip') and notes optional filters. It is not vague or tautological, but it does not explicitly differentiate trip items from sibling list tools like trip_activity_list or trip_note_list, so it misses full sibling differentiation.

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

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

Provides no guidance on when to choose this tool over alternatives, and no exclusions or context. With multiple sibling list tools (trip_activity_list, trip_task_list, trip_note_list), an agent must infer from the name alone; the description doesn't clarify use cases or boundaries.

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

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

Beyond annotations (readOnlyHint=false, destructiveHint=false), it describes the parsing/geocoding behavior, the example, and the ability to repair one or all transport items. It doesn't discuss failure modes or geocoding dependencies, but annotations already signal a mutating, non-destructive repair 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 description is two sentences with a concrete example and no filler. Key information is front-loaded, making it easily scannable.

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

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

For a repair tool with 5 optional parameters and no output schema, the description covers the main behavior, scope, and parsing/geocoding mechanism. It doesn't specify behavior when no parameters are supplied or if both itemId and tripId are provided, but the schema covers parameter semantics sufficiently.

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 reinforces that itemId selects a single item and tripId selects all transport items, and the example clarifies how names are parsed. It adds minimal parameter-level 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 names a specific action ('repair'), a specific resource ('transport/flight items missing origin coordinates'), and the mechanism (parse item name + geocode). It gives a concrete example and states scope (single item or all in trip), which distinguishes it from generic trip_item_update or trip_transport_add.

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 clearly specifies the intended use case: items missing origin coordinates that need parsing/geocoding, and mentions both single-item and trip-wide repair. It doesn't explicitly name alternative tools or exclusion conditions, but the context is unmistakable.

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

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

The annotations already convey the safety profile (readOnlyHint=false, destructiveHint=false), and the description adds no behavioral context beyond restating that a mutation occurs. It does not disclose whether the update is a partial merge or a full replacement, whether itemId itself is mutable, or whether status changes are validated against the canonical enum workflow. With annotations covering the basics, the description contributes essentially nothing extra.

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?

Four words with no filler and a front-loaded verb — structurally efficient and easy to parse. The brevity borders on under-specification, but that is a content gap penalized in other dimensions rather than a structure or conciseness flaw.

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 11 parameters and no output schema, this description is a stub. An agent cannot determine whether the call returns the updated item, whether unspecified fields are preserved, or whether constraints like timeStart preceding timeEnd apply. A tool of this complexity needs at least a sentence on update semantics and return behavior, and it has none.

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 of 3 applies. The schema already documents all 11 parameters thoroughly, including canonical status values, legacy aliases, and date/time formats. The description adds zero parameter-level meaning, but no compensation is needed because the schema carries the full burden.

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') and a specific resource ('a trip item'), which clearly signals a modification operation distinct from trip_item_add, trip_item_delete, and trip_item_list. It is unambiguous but does not explicitly contrast with siblings or hint at the workflow position of updates, so it stops short of full differentiation.

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 — no mention that the item must already exist (e.g., created via trip_item_add), no note on trip-edit permissions, and no direction on when to update in place versus delete-and-recreate. The single sentence 'Update a trip item' leaves all usage decisions 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?

The description adds meaningful behavioral context beyond the annotations by disclosing the toggle behavior: 'Voting the same way twice removes your vote.' This is important state-changing behavior that is not inferable from readOnlyHint or destructiveHint alone.

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

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

The description is two short sentences with no filler. It front-loads the primary action, then immediately provides the key eligibility constraint and toggle behavior. Every sentence contributes essential 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 two-parameter tool with no nested objects and no output schema, the description covers the operation, eligibility, and toggle behavior. It does not describe the response payload or error cases, but these are not required for an agent to invoke the tool correctly.

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

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

Schema description coverage is 100%, with 'Vote direction' and 'Trip item ID' already documented in the input schema. The description does not add significant extra meaning to the parameters beyond what the schema already 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 states a specific action ('Vote UP or DOWN on a trip item') with a clear resource and direction. It clearly differentiates this tool from sibling tools like trip_item_add, trip_item_update, and trip_item_delete by describing the exact voting semantics.

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

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

The description explicitly states when the tool is available: 'Only available for IDEA, RESEARCHED, and SHORTLISTED items.' This gives an agent a clear precondition and implies when not to use the tool, which is strong usage guidance for this simple tool.

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

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

The annotations already declare readOnlyHint=true and destructiveHint=false, so the agent knows this is a safe read operation. The description adds only the authenticated-user scoping; it does not mention return format, ordering, or pagination, which is acceptable given the annotation coverage but not deeply 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?

A single front-loaded sentence with no filler; it is appropriately concise for a simple list operation. It loses a point because it is so terse that it does not enrich the title with sibling routing or filter hints, though that is a content rather than structural issue.

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 one optional, schema-described parameter and safety annotations, the description covers the essential purpose and auth scope. It does not restate the optional status filter, but the schema fully covers that, and no output schema creates an obligation to describe return values.

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, status, is fully documented in the schema with an enum and the description 'Filter by status', so the tool description has no obligation to restate it. With 100% schema description coverage, the baseline 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 ('List'), a resource ('trips'), and a scope ('for the authenticated user'), making the core function clear. It implicitly distinguishes from single-trip tools such as trip_get, but it never names any sibling alternative, so it falls short of the strongest differentiation.

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 is provided against search, fetch, or trip_get. The phrase 'all trips for the authenticated user' implies a use case, but selection among the many sibling tools is left mostly 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?

Annotations already indicate readOnlyHint=false and destructiveHint=false, so the 'save' description is consistent. The description adds minimal context beyond the annotations, mainly that coordinates are part of the saved location. It does not address duplicate handling, overwrite behavior, validation, or return effects.

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 or redundant wording. It communicates the core action and key constraint 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?

Combined with a fully-described schema and annotations, the description is minimally sufficient for a simple add operation. However, it lacks sibling differentiation, usage conditions, and any mention of side effects or response shape. The schema carries most of the invocation burden.

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 fully documents all 10 parameters. The description's mention of 'coordinates' usefully points to the required latitude/longitude fields, but it adds little meaning beyond the detailed schema descriptions.

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

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

The description uses a specific verb and resource: 'Save a location to a trip', which clearly indicates the operation and distinguishes it from trip_location_delete/list/nearby. It also calls out coordinates as a key part of the operation. However, it does not explicitly contrast with the close sibling trip_item_add, and 'location' is somewhat generic 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?

No guidance is given about when to use this tool versus alternatives such as trip_item_add or trip_transport_add. The sentence states only what the tool does, not the conditions, prerequisites, or context that should trigger its 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?

Annotations already declare destructiveHint=true and readOnlyHint=false, so the destructive nature is disclosed. However, the description adds no additional behavioral context—it never mentions irreversibility, cascading effects, permissions, or consequences of deleting a location. It simply restates the action without enriching what annotations already provide.

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, terse sentence with zero wasted words. It front-loads the action and is appropriately sized for a simple delete 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 basic delete with one parameter, the description, schema, and annotations together convey the essential information. It lacks explicit statements about permanence or side effects, but given the simplicity of the operation, this is adequate yet not rich.

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 locationId parameter is documented with 'Location ID'. The description does not add any extra meaning or format details beyond this, so the baseline 3 is appropriate since the schema fully covers the parameter.

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

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

The description 'Delete a saved location' uses a specific verb and resource, making it immediately clear what the tool does. It distinguishes from sibling location tools (add, list, nearby) because deletion is the only destructive operation among 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 provides no guidance on when to use this tool versus alternatives, such as whether to verify the location exists first or if there are any restrictions (e.g., cannot delete a location referenced by other entities). No context is given for prerequisites or when to prefer other trip-related 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?

The annotations already declare readOnlyHint=true and destructiveHint=false, so the safe read-only behavior is covered. The description itself adds no further behavioral context, such as pagination, ordering, or interactions between the optional filters.

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 or redundant language. It is immediately parseable and every word contributes to the 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-only list tool, the schema and annotations cover the required parameter and safe access. However, the description omits any indication of return shape and does not differentiate among sibling list tools, leaving it minimally adequate 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?

All four parameters have descriptions in the input schema, including the required tripId and the optional city, country, and type filters, so the schema carries the semantic load. The description adds no parameter-level detail beyond the word 'trip.'

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 'List' and a clear resource, 'saved locations for a trip,' which unambiguously indicates the operation. It is clearly distinct from add/delete/nearby siblings, though it does not explicitly contrast with trip_activity_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?

Usage is implied by the verb and resource: call this when you need the saved locations for a trip. However, there is no explicit guidance about when to prefer this over trip_location_nearby, trip_activity_list, or trip_item_list.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description does not need to repeat that. It does add the 'within radius' scoping, which is also in the schema (radiusKm). No additional behavioral detail is provided (e.g., return format, ordering, or pagination). It meets the minimum given annotations.

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

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

The description is a single concise sentence that front-loads the action and scope. There is no wasted text, and it is appropriately sized for the tool's simplicity.

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

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

For a read-only query tool with 4 parameters and no output schema, the description does not explicitly state what the tool returns (e.g., a list of saved locations). It leaves this to inference. While annotations cover safety, the return type is ambiguous, which is a gap given the absence of an output schema.

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

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

Schema description coverage is 100%, with each parameter having a basic description (e.g., 'Trip ID', 'Center latitude'). The tool description reinforces the radius concept but does not add meaning beyond the schema. Since the schema is complete, 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?

The description clearly states the verb 'Find' and the resource 'saved locations', and specifies the proximity condition 'near coordinates (within radius)'. This distinguishes it from trip_location_list (which lists all locations) and trip_location_add/delete. However, it does not explicitly mention the trip context (tripId), which is inferred from the tool name and parameter.

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

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

No guidance is given on when to use this tool versus alternatives like trip_location_list. The description does not exclude other use cases or mention scenarios where this tool is preferred. An agent must infer the usage from the tool name and parameters 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?

Annotations already declare readOnlyHint=false and destructiveHint=false, so the mutation/safety profile is covered. The description adds modest context about the free-form nature and allowed content types, but does not disclose return values, side effects, or permissions. There is no contradiction with the annotations.

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

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

The description is a single, front-loaded sentence with no filler. Every element adds value: the action, the target resource, the trip scope, and concrete use cases.

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 create tool with fully documented parameters, the description plus schema is sufficient for an agent to invoke it correctly. It lacks an explicit statement about the return value, but no output schema exists and the operation is straightforward, so this is a minor 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 parameters are already well documented and the baseline is 3. The description reinforces the 'free-form' nature of content but does not add meaningful parameter 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 uses a specific verb ('Create') and names a clear resource ('free-form note for a trip'), with concrete examples. It distinguishes itself from note lifecycle siblings through the create verb and from item/task tools via 'free-form note,' though it does not explicitly contrast any sibling.

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

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

There is no guidance on when to use this tool versus alternatives like trip_item_add or trip_task_create. The description implies 'when you create a note,' but it gives no exclusions, prerequisites, or decision rules to help an agent choose among the many create-oriented 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?

The annotations already declare destructiveHint=true and readOnlyHint=false, so the destructive nature is externally covered. The description adds no behavioral context beyond what annotations provide, such as permanence, cascading effects, or whether confirmation is 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?

The description is extremely concise, containing only the essential verb and object with no filler. All information is front-loaded, and nothing is wasted.

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 destructive tool, the description plus the annotation and schema provide enough information for an agent to invoke it correctly. It is slightly incomplete in that it does not clarify the 'trip note' scope, but the tool name and sibling context fill that 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%: the 'noteId' parameter is already documented as 'Note ID'. The description adds no additional semantic meaning, 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 ('Delete') and a resource ('a note'), which is clear and not a tautology. However, it does not explicitly distinguish trip notes from other delete-capable resources, though the tool name and title help disambiguate.

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 siblings like trip_note_update, trip_note_list, or trip_delete. There are no conditions, exclusions, or alternative recommendations, leaving the agent to infer usage solely from the 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds the optional date filter behavior but does not disclose other behavioral details such as ordering, pagination, or auth requirements. There is no contradiction with annotations.

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

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

The description is a single, tightly worded sentence that front-loads the core operation ('List notes for a trip') and appends the optional filter. Every word earns its place, and there is no unnecessary repetition of the tool name or schema details.

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

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

For a simple read-only listing tool with fully documented parameters and safe annotations, the description is sufficient. It clearly conveys the action, scope, and available filter. It does not detail the return shape, but 'List notes' reasonably implies a list of note objects, and no output schema exists to demand more.

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 tripId and noteDate are already documented in the schema. The description's 'optional date filter' mirrors the noteDate schema description without adding significant new meaning, 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 uses a specific verb and resource ('List notes') scoped to a trip, which distinguishes it from sibling tools like trip_item_list, trip_task_list, and trip_note_create/update/delete. It also includes the optional date filter, making the operation precise and 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 phrase 'for a trip' implies the tool is used to fetch notes associated with a specific trip, but the description does not explicitly state when to use this over related tools like trip_item_list or trip_task_list. No exclusions or alternative tool guidance 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?

The annotations already provide readOnlyHint=false and destructiveHint=false, and the description merely says 'Update a note.' It adds no behavioral context such as whether fields are patched or fully replaced, whether auth is required, or any side effects.

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 fluff, but it is under-specific rather than effectively concise. It tells the agent no more than the tool name and annotation title already imply.

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 mutating tool with four parameters and no output schema, the description is too thin. It does not explain partial-update semantics, which fields can be changed, or the effect of omitting optional fields, and there is no usage guidance to make the tool complete to 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?

The input schema has 100% description coverage for all four parameters, so the schema carries the semantic weight. The description adds no parameter-level detail, but the baseline of 3 is appropriate because there is no gap to compensate for.

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 'Update a note' states a verb and resource, so it is not misleading, but it adds no scope beyond the name/title and reads as a restatement of the annotation title. It does not clarify this is a trip note update or what aspects can be updated, making it only minimally adequate.

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 use this tool versus trip_note_create, trip_note_delete, or trip_note_list. There are no exclusions, prerequisites, or alternative routing, so the agent receives no decision support.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds valuable behavioral detail beyond annotations by specifying exactly what kinds of findings the review surfaces and that transport gaps come with suggested modes. It stops short of discussing latency or limits, but those are less critical for a read-only review 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 detailed yet tightly organized: purpose and return values come first, explicit call triggers follow, and the actionable follow-up closes it. Every sentence earns its place, and the bullet-like trigger list is easy for an agent to parse.

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

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

There is no output schema, so the description carries the burden of explaining return values—and it does, enumerating the categories the review returns. With one parameter, clear annotations, and explicit usage triggers, nothing essential is missing for an agent to select and invoke 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 100%: tripId is documented as 'Trip ID to review' in the schema itself. The description does not add additional parameter-level meaning, but with one obvious, fully documented parameter, the baseline 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 and resource: 'Review a trip for completeness and get actionable suggestions.' It then enumerates distinct outputs—missing transport, outdated routes, empty days, unbooked items, missing coordinates—that differentiate it clearly from sibling tools like trip_get or trip_activity_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?

The description explicitly lists when to call the tool: after adding several items, when the user asks to review/optimize/check, before sharing, when asking 'what's missing?', or within 7 days of departure. It also identifies the follow-up action of calling trip_transport_add for gaps, giving concrete 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?

Annotations already indicate this is not read-only and not destructive. The description adds meaningful behavioral context beyond that: it requires owner authorization, creates a share link, and the link lets recipients become collaborators. This gives the agent an accurate expectation of the tool's side effect.

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

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

The description is two short sentences with no filler. It front-loads the primary purpose and immediately adds the most important constraint ('owner only') and the follow-on effect for recipients.

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 four well-documented parameters and no output schema, the description provides essential context: the action, the authorization requirement, and the consequence for recipients. It is complete enough for an agent to select and invoke this tool correctly, though it does not cover edge cases like link expiry or revocation.

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

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

Schema description coverage is 100%, so each parameter already has a clear description in the schema. The tool description does not add parameter-specific details beyond what the schema provides, so the baseline score 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 action ('Create a share link'), a clear resource ('for a trip'), and a key constraint ('owner only'). It is clearly distinguishable from sibling tools like trip_share_list and trip_share_revoke because it explicitly describes the creation action and the recipient effect.

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: this tool is for creating share links and is restricted to the trip owner. It does not explicitly name alternatives or exclusions, but the owner-only note and the recipient-collaborator effect make the intended usage clear relative to the sibling share/list/revoke 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?

Annotations already carry readOnlyHint=true and destructiveHint=false, so the safety profile is established. The description adds a genuinely useful behavioral trait beyond the annotations: the owner-only authorization constraint, which an agent needs to know before calling. There is no contradiction between the 'List' verb and the readOnlyHint.

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 verb and resource front-loaded, and the ownership constraint efficiently parenthesized. Every word earns its place; there is no filler or repetition of what the annotations already state.

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

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

For a single-parameter, read-only list tool whose annotations cover the safety profile, the description covers purpose, scope, and authorization — the essentials. Minor gaps remain: there is no output schema, so the return shape of the share links is unstated, and behavior when a non-owner calls the tool is not described. These are acceptable omissions for such a simple tool.

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

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

Schema description coverage is 100% (tripId is already documented as 'Trip ID'), so the baseline is 3. The description's 'for a trip' phrase loosely reinforces that tripId identifies the trip whose share links are listed, but it adds no format, validation, or additional semantic detail 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 'List all share links for a trip (owner only)' names a specific verb (List), a specific resource (share links), and a scope (for a trip), which clearly distinguishes it from siblings like trip_share_create, trip_share_revoke, and trip_collaborators_list. The 'owner only' qualifier further sharpens the purpose. An agent can tell exactly what this tool does 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?

The description gives useful context ('owner only') which implies a prerequisite, and the sibling naming convention suggests this is the read counterpart to trip_share_create/trip_share_revoke. However, it never explicitly states when to use this tool versus alternatives or when not to use it. Usage must be inferred rather than spelled out.

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

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

Annotations already indicate readOnlyHint=false and destructiveHint=true, so the destructive nature is covered. The description adds an authentication/authorization requirement ('owner only'), which is behavioral context beyond the structured annotations.

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

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

The description is a single compact sentence that conveys the operation, the resource, and the access restriction without any redundant phrasing. Every word contributes value.

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

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

For a simple single-parameter destructive operation with annotations covering the destructive hint and the description covering the owner-only condition, the essential context is present. There is no output schema, but none is needed to understand the basic call. More detail about side effects or permanence could slightly improve completeness, but the annotations already mitigate that gap.

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

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

The input schema already provides 100% coverage with a clear description for the single parameter, shareLinkId. The tool description does not add any additional parameter-level meaning, matching the baseline for schema-heavy 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 states a clear action ('Revoke/delete') on a specific resource ('a share link') and adds a critical scope condition ('owner only'). This makes its purpose immediately distinguishable from sibling tools like trip_share_create and trip_share_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?

The 'owner only' condition gives useful context about who may invoke this tool. However, the description does not explicitly state when to prefer this tool over alternatives such as trip_share_create or trip_share_list, leaving the decision implied 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?

Annotations already indicate readOnlyHint=false and destructiveHint=false, so the mutation is known. The description adds no extra behavioral context such as idempotency, effects on already-completed tasks, or whether the change is reversible.

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 clear sentence with no filler or repetition. It front-loads the action and the target state 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?

For a simple one-parameter tool, the core action is adequately stated. However, the lack of usage guidance and behavioral side effects leaves some ambiguity about when this is the right tool versus trip_task_update, making it minimally complete rather than fully 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?

The input schema fully documents the only parameter, taskId, as 'Task ID' with 100% coverage. The description adds no additional meaning or constraints beyond what the schema already provides, so it meets the baseline for schema-covered parameters.

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

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

The description states a specific action and result: 'Mark a task as completed.' It is clear about what the tool does and is distinct from generic siblings like trip_task_update and trip_task_list, though it does not explicitly call out that 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 description gives no guidance about when to use this tool instead of sibling tools such as trip_task_update or trip_task_create. There is no mention of prerequisites, task ownership, or whether this is preferred over updating a task's status directly.

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

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

Annotations already declare readOnlyHint=false and destructiveHint=false, so the agent knows this is a non-read-only, non-destructive mutation. The description adds no behavioral context beyond the create operation itself—no mention of side effects, duplication, permissions, or resulting state. It does not contradict the annotations.

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

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

The description is a single front-loaded sentence that states the action and resource, followed by a useful illustrative example. There is no redundancy 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?

For a create tool with only two required parameters and a fully described schema, the description and schema together are sufficient to invoke it correctly. It could mention that tasks are scoped to a tripId, but the schema already makes that explicit, and no output schema means return-value details are not required.

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 in the input schema. The description's examples illustrate what kinds of tasks to create but add no parameter-specific meaning 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 uses the specific verb 'Create' with a clear resource, 'a task/reminder for a trip,' and gives concrete examples (renew passport, book activity). This clearly distinguishes it from sibling task tools like trip_task_list, trip_task_update, and trip_task_delete.

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 guidance on when to use this tool versus alternatives such as trip_task_update, trip_task_complete, or trip_note_create. Usage is only implied by the verb 'Create' and the tool name; no contexts, exclusions, or alternative routing 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?

The annotations already declare destructiveHint=true and readOnlyHint=false, so the agent knows this is a destructive mutation. The description adds no additional behavioral context, such as whether deletion is permanent, whether it cascades to related data, or whether special permissions are required. It does not contradict the annotations, but it also does not go beyond them.

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?

'Delete a task' is concise, front-loaded, and contains no unnecessary words. For a simple deletion operation, this length is appropriate, though it sacrifices informational richness in other dimensions.

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 one-parameter destructive operation, this is minimally viable: the schema covers the parameter and the annotations cover the destructive nature. However, the description does not mention irreversible consequences, side effects, or what happens after deletion, and there is no output schema to clarify the return value.

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 taskId described as 'Task ID'. The description itself adds no extra meaning beyond the schema, so it sits at the baseline 3 for a fully documented parameter.

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

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

The description 'Delete a task' clearly states the verb and resource, distinguishing it from sibling tools like trip_task_create, trip_task_update, and trip_task_list. It is unambiguous about the operation's nature, though it does not explicitly mention the trip context carried by the tool name.

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 trip_task_update or trip_task_complete. There are no prerequisities, exclusions, or hints about when deletion is the right choice, leaving the agent to rely on the tool 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description adds no behavioral details beyond that. There's no mention of defaults like the includeCompleted=false behavior or any response characteristics, so it provides little transparency value beyond the annotations.

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

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

The description is one short sentence with no filler or redundant wording. It is efficient and immediately readable.

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 100% schema coverage, the description is nearly complete. It could be stronger by clarifying the default exclusion of completed tasks, but the schema's includeCompleted default communicates 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?

All three parameters are fully documented in the input schema (tripId, status enum, includeCompleted with default). The description contributes no additional parameter meaning, so it stays at the schema-covered baseline.

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 ('List') and resource ('tasks for a trip'), making the core operation clear. It doesn't explicitly distinguish among the many task-related siblings, but the task resource and read-only framing are unambiguous.

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

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

No guidance is given about when to use this tool instead of trip_task_create/complete/delete/update or trip_item_list. The read-only intent is implied by 'List,' but no alternatives or exclusions are 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?

The annotations already indicate a mutating, non-destructive operation, and the description adds no further behavioral context. It does not disclose whether the update replaces the whole task or only supplied fields, what side effects occur, or what preconditions apply.

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

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

The description is extremely short but under-specified rather than efficiently complete; it repeats the title without adding value. A three-word sentence is not an appropriate description for an 8-parameter 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?

Given the tool's mutating nature, eight parameters, no output schema, and many sibling tools, this one-line description is insufficient for an agent to invoke it confidently. The schema covers field details, but the tool's behavior, return value, and relationship to other task tools remain unspecified.

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 eight parameters are already documented with types, formats, and enums. The description contributes no additional parameter meaning, but the baseline of 3 applies because the schema carries the documentation burden.

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 is a near-verbatim restatement of the tool name and title ('Update a task' / 'Update Task'). It names the verb and resource but adds no specificity, and it does not differentiate from sibling tools such as trip_task_complete or trip_update, which also operate on task/trip-related resources.

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. An agent is not told how this differs from trip_task_create, trip_task_complete, or trip_task_delete, nor whether it supports partial updates or requires an existing task.

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

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

Annotations only provide readOnlyHint=false and destructiveHint=false, so the description carries much of the burden. It usefully notes that both origin and destination are required for correct map routing, but it does not disclose other behavioral details such as side effects beyond item creation, validation outcomes, or what the response contains. This is adequate 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?

Two concise sentences deliver the core purpose, the sibling exclusion, and the critical usage constraint. Every sentence earns its place and the most important routing instruction 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 17-parameter tool with no output schema, the description covers purpose, required parameters, and the key alternative. The schema fully documents optional parameters, so the description does not need to repeat them. A small gap remains around what happens after a successful add (e.g., return value or generated item location), but overall this is complete enough for safe invocation.

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

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

Schema coverage is 100%, so the baseline applies: the schema documents all parameters thoroughly. The description adds the key guidance that origin and destination are both required and highlights transport type examples, but it does not meaningfully extend parameter meaning beyond the schema. This meets the baseline without exceeding it.

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

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

The description uses a specific verb ('Add') and resource ('transport item ... to a trip'), lists the supported transport types, and explicitly distinguishes itself from trip_item_add. An agent can clearly understand what this tool does and why it exists.

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

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

The description explicitly states 'ALWAYS use this instead of trip_item_add for transport,' naming the sibling alternative and the exact condition for choosing this tool. It also clarifies the required origin/destination fields and their purpose, leaving no ambiguity about when to invoke 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?

The annotations already indicate readOnlyHint=false and destructiveHint=false, so the description adds no additional behavioral transparency. It does not disclose whether updates are partial or full replacements, whether fields are validated, what happens on invalid data, or what the response contains.

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 or redundant phrasing. It is front-loaded and easy to parse, though its brevity borders on under-specification.

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 output schema, this description is incomplete. It does not explain return behavior, partial-update semantics, required preconditions, or the meaning of 'details' beyond what the schema lists. An agent would need to infer most call context from the schema alone.

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 documents all parameter names, types, formats, and the status enum. The description adds no parameter-level meaning, but the schema carries the full burden, 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 says 'Update trip details', which names a verb and a resource, so the basic purpose is clear. However, it is essentially a restatement of the tool name and title, and it does not say which trip details can be changed or how it differs from sibling tools like trip_item_update. This makes the purpose somewhat vague without relying on 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?

There is no guidance about when to use this tool versus alternatives such as trip_create, trip_delete, or trip_item_update. The description provides no context about prerequisites, editability conditions, or situations where a different tool should be chosen.

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