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 only indicate non-read-only and non-destructive behavior. The description adds meaningful behavioral context: boardLabel can find-or-create a board, and enrichment is best-effort and never blocks the save. This goes beyond the annotations, though it does not address error or conflict behavior when params are combined.

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

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

Three sentences, each earning its place: the core save action, the important boardLabel behavior, and the enrichment caveat. The most relevant guidance is front-loaded, with no filler or repetition 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 tool with four optional params and no output schema, the description covers the main behavioral nuance and gives enough context to use it safely. It does not state the return/success shape or what happens if url/text or board context is missing, but these are minor gaps for a straightforward capture 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 coverage is 100%, so the baseline is 3. The description adds extra semantics by telling the agent to use boardLabel without boardId in a conversational context and by clarifying that enrichment is non-blocking. This is useful guidance beyond the schema's per-parameter descriptions.

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

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

The description opens with a specific verb and resource: 'Save a link or a note as an idea on a board.' The phrase 'generic capture inbox for idea boards' distinguishes this from board-management siblings like idea_board_create and idea_list. An agent can clearly tell this is the capture/write tool for ideas.

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 explicit in-tool usage guidance: 'Pass boardLabel with no boardId to find-or-create a board by that freeform label,' and explains why this matters in a conversational client. It does not explicitly mention when to choose idea_add over sibling tools, but the context is clear enough to avoid obvious confusion.

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 readOnlyHint=false and destructiveHint=false, and the description confirms a creation side effect. It adds useful semantic context about idea boards being non-committal and pre-trip, but does not disclose return behavior, prerequisites, or other side effects; 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 compact sentence that front-loads the action and adds a purposeful parenthetical. Every word contributes either to the action or to the conceptual context, with no filler or redundancy.

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

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

For a simple two-parameter create operation with fully documented schema and safety annotations, the description is nearly complete. It clearly communicates the tool's purpose and semantics; the only notable gap is that it does not describe what the call returns, though this is not essential for correct invocation.

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

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

The input schema provides full descriptions for both parameters (label and description), so the description does not need to repeat them. It adds no parameter-level guidance, matching the baseline for high schema coverage.

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

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

The description states a specific verb-resource pair ('Create a new idea board') and adds a clarifying parenthetical defining it as a non-committal, pre-trip destination scratchpad. This clearly distinguishes it from other idea_board_* tools and trip-focused tools.

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

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

The parenthetical implies the intended use case (pre-trip, non-committal scratchpad) but does not explicitly state when to use this tool versus alternatives like trip_create or idea_add. There is no when-not-to-use guidance or routing to sibling 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 flag destructiveHint=true, and the description adds the key behavioral detail that deletion cascades to all ideas on the board. This goes beyond the annotation by specifying scope, though it does not mention irreversibility or any confirmation requirement (which the schema covers).

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, tightly worded sentence that front-loads the core action and its most important consequence. No filler or redundancy.

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

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

For a destructive operation with two fully documented parameters and no output schema, the description adequately covers what the tool does and its scope. It could mention that confirm must be true, but that is already in the schema, so nothing critical is missing.

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

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

Schema description coverage is 100% for both boardId and confirm, so the schema fully documents parameters. The description adds no extra parameter context, meeting the baseline for full coverage without requiring compensation.

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

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

The description states a specific verb ('Delete') and resource ('idea board') and explicitly clarifies it removes every idea on it, distinguishing it from the sibling idea_remove that targets individual ideas. The purpose is unmistakable.

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

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

The description implies this is for board-level deletion but does not explicitly mention alternatives like idea_remove or provide when-not-to-use guidance. The context of the name and the cascade note make usage fairly clear, but it relies on inference rather than explicit direction.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, covering the safety profile. The description adds that the response includes idea counts, but does not disclose other behavioral aspects like pagination, ordering, or response structure beyond that.

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

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

A single sentence with no filler: the action, resource, scope, and returned detail are all packed into eight words. It is immediately readable and 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 read-only listing tool with no parameters, the description conveys the essential behavior. It does not describe the exact return shape, but 'with idea counts' gives the key expected content, and annotations handle safety. Sibling differentiation is the main missing piece.

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

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

The tool has zero parameters and schema coverage is 100%, so there is nothing left for the description to explain about parameters. This matches the baseline for a no-parameter tool.

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 ('idea boards'), and 'the caller's' adds useful scoping. It does not explicitly contrast with sibling idea_list, though the resource type makes the distinction inferable.

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

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

The context of use is implied: retrieve boards belonging to the caller. There is no explicit statement of when to prefer this tool over alternatives like idea_list or when not to use it, so the guidance is sufficient but not proactive.

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, indicating a non-read-only, non-destructive operation. The description adds 'or update its description,' but this is merely a restatement of the schema parameter and does not disclose side effects, reversibility, or permissions. 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, front-loaded sentence stating the action and resource without any unnecessary words. It efficiently covers both rename and description-update functionality.

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 mutation tool with full schema coverage and annotations present, the description gives the core purpose. However, it does not mention that label is always required (even when only updating description), nor any potential prerequisites. The schema covers required fields, so the overall picture is adequate but minimal.

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%: each parameter (boardId, label, description) is fully described in the input schema, including behavior for omitted/empty description. The tool description adds no parameter-level meaning beyond the schema, 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 action (rename) and resource (idea board), and also covers updating the description. It clearly differentiates from sibling tools like idea_board_create, idea_board_delete, and idea_board_list, though it does not explicitly name those alternatives.

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

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

No guidance is given on when to use this tool versus alternatives. It does not mention exclusions, prerequisites, or compare with sibling tools like idea_board_create or idea_board_delete.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, covering the safety profile. The description adds no extra behavioral context such as pagination, ordering, or error handling. Since the bar is lower with annotations present and the description is consistent, a 3 is appropriate for the minimal value added.

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

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

The description is a single, concise sentence with zero waste. It is front-loaded with the verb and resource, making it immediately clear what the tool does.

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

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

For a simple list tool with a single required parameter, the description is adequate. It states the function clearly and implicitly covers listing all ideas on the board. While it does not describe return format or pagination, the absence of an output schema means that is not strictly required. Given the tool's simplicity, it is reasonably complete.

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

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

Schema description coverage is 100%, and the schema already describes boardId as 'Idea board ID'. The description does not add any parameter-specific meaning beyond what the schema provides, so the baseline of 3 is correct.

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

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

The description 'List the ideas on an idea board' uses a specific verb 'List' and a clear resource 'ideas' on an 'idea board', which distinguishes it from siblings like idea_board_list (lists boards) and idea_add (adds ideas). It is clear and unambiguous, though it does not explicitly name alternatives, so it misses the top score.

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 explicit guidance on when to use this tool versus alternatives. It implies usage by mentioning the board, but does not state any exclusions or compare with other list tools such as search or idea_board_list. There is no mention of prerequisites beyond what the schema implies.

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 are weak (readOnlyHint=false, destructiveHint=false) and the description merely restates the core mutation without adding behavioral context. It does not disclose side effects on the source board, atomicity, permissions, or error conditions beyond what the operation name itself implies.

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

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

The description is a single, front-loaded sentence with no wasted words. It states the action and the object 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 tool with complete schema descriptions, the description is minimally adequate, but it lacks guidance on selecting this tool over nearby siblings and provides no behavioral caveats. It is enough to understand the operation, but not enough to fully contextualize it.

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

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

The input schema covers both parameters with descriptions ('Idea ID', 'Destination board ID'), so the schema already carries the semantic weight. The description adds little beyond the word 'different board', which is marginally useful but not a significant enrichment.

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 ('Move') and a specific resource ('an idea') to a different board. It is unambiguous, but it does not explicitly differentiate this from sibling tools like idea_add or idea_remove, so it stops short of a 5.

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

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

The intended use is implied by the verb 'move' — an agent can infer it should be used when relocating an idea between boards. However, there is no explicit guidance on when not to use it or how it compares to alternatives like idea_add + idea_remove.

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 core destructive nature is disclosed. The description adds no further behavioral context such as permanence, side effects on the board, or authorization requirements.

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

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

The description is a single six-word sentence with no filler. The action and target are immediately clear and 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 one-parameter, clearly destructive action, the schema and annotations cover the essentials needed to invoke the tool. The main missing context is whether removal is permanent or has side effects on the board, but the destructiveHint already signals the risk.

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

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

Schema coverage is 100% and the only parameter, ideaId, is described as 'Idea ID'. The description adds no additional meaning beyond what the schema already provides, so the baseline of 3 applies.

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

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

The description states a specific verb ('Remove') and a clear resource ('an idea from its board'). It is distinguishable from sibling tools like idea_add, idea_move, and idea_board_delete without requiring schema inspection.

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 usage context is implied: use this to delete or remove a single idea. However, the description does not explicitly state when not to use it or name alternatives such as idea_board_delete or idea_move.

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 description repeats the create action without disclosing side effects, validation behavior, defaults, ID generation, or post-creation effects. Annotations declare readOnlyHint and destructiveHint as false but do not compensate for the missing behavioral context.

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

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

The description is a single short sentence with no wasted words and the key verb is front-loaded. It is concise, though arguably too sparse for a tool with nine parameters and no output schema.

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

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

With nine parameters, four required fields, and no output schema, the description provides no information about what the tool returns, how success is reported, or when creating a new trip is preferable to cloning/updating. The schema is rich, but the tool-level context remains incomplete.

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

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

Schema description coverage is 100%, and each parameter already has meaningful descriptions, including formats, defaults, and coordinate guidance. The description adds no 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 clear verb and resource ('Create a new trip') and the word 'new' hints at a distinction from sibling trip_clone. It is not a full tautology, but it adds no detail beyond what the tool name and title already imply.

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_clone, trip_update, or trip_delete. The only implied usage is 'create a new trip,' with no exclusions or decision criteria.

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

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

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

Annotations already communicate a non-destructive mutation (readOnlyHint=false, destructiveHint=false), and the description's 'Add' merely restates that operation without adding context. It does not disclose side effects such as geocoding, smart sort placement, timezone defaults, or what happens on success.

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

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

The description is a single compact sentence with no filler, and the parenthetical enumeration of item types is useful and front-loaded. Every word earns its place.

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

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

The rich schema and annotations make the tool invokable for basic use, but the overall definition is incomplete for a 27-parameter tool with no output schema: it lacks return behavior, prerequisites, failure semantics, and explicit routing to trip_transport_add for transport items. It is adequate, but with clear gaps.

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

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

Schema description coverage is 100% and the parameter descriptions are unusually rich (status aliases, timezone defaults, sortOrder behavior, geocoding notes), so the schema carries the parameter-documentation burden. The top-level description adds no parameter meaning beyond what the schema already 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 concrete action and resource ('Add an item to a trip') and enumerates the accepted item types, so an agent can tell what the tool does at a glance. It is not quite a 5 because it does not differentiate this from trip_transport_add, which is the preferred sibling for FLIGHT/TRANSPORT 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?

The description gives no when-to-use guidance or exclusions, despite many nearby sibling tools such as trip_transport_add and trip_item_update. The schema's origin* parameter descriptions mention preferring trip_transport_add for FLIGHT/TRANSPORT, but the tool description itself does not guide the agent toward or away from alternatives.

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

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

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

Annotations already declare readOnlyHint=false and destructiveHint=false, so the description doesn't need to cover safety. The description adds a valuable behavioral detail: automatic geocoding when an address is updated without coordinates. This is non-obvious and helps the agent anticipate side effects. However, it doesn't disclose other behaviors like partial-update semantics or error handling, but the bar is lower given 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 sentence that is both concise and informative. It states the core action and adds a relevant behavioral caveat without any fluff. Every word earns its place, making it highly efficient for an agent to parse.

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

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

Given the tool has 25 parameters and no output schema, the description is minimal. It doesn't clarify whether the update is partial (only provided fields are changed) or whether omitted fields are reset. It also doesn't mention error cases like non-existent itemId. The schema descriptions are thorough, but for a complex mutation tool, the description should state the update semantics to avoid misinterpretation.

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 25 parameters have descriptions. The tool description's geocoding note is redundant because the schema already states 'will be geocoded if no coordinates provided' for both address and originAddress. The description adds no new meaning to parameters beyond what the schema provides, so a 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 clearly states the tool updates a trip item, providing a specific verb and resource. It doesn't explicitly differentiate from sibling update tools like trip_note_update or trip_update, but the resource 'trip item' is unambiguous given the name. The geocoding note adds a specific behavior but doesn't contrast with alternatives.

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

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

The description gives no guidance on when to use this tool versus alternatives. There is no mention of prerequisites, conditions, or exclusions. An agent must infer that this is the general update tool for trip items based solely on the name, without any explicit routing to or from 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 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 indicate readOnlyHint=false and destructiveHint=false, so the description must clarify mutation behavior. It adds that origin/destination are required for map routing display, which is a useful behavioral note. However, it doesn't disclose side effects, potential failures, or how the transport item relates to other trip items beyond the linked_item_id parameter. The description carries some burden but could be richer.

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, front-loaded with the core purpose and the crucial 'ALWAYS use this instead of trip_item_add' instruction. There is zero waste; every word contributes to selection and usage guidance.

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

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

With 20 parameters and no output schema, the description is brief. It adequately covers the high-level purpose and the key differentiator from trip_item_add. However, it doesn't mention any preconditions (e.g., trip must exist), return behavior, or edge cases like flights vs other transport. The schema handles parameter details, but the description could offer more context about how transport items integrate with trip items (e.g., linking). It's adequate but not thorough.

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

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

Schema description coverage is 100%, so all 20 parameters already have descriptions. The description mentions that origin and destination are required, which is already in the schema's required list, so it adds no new semantic value. It doesn't clarify any parameter interactions or formats beyond what the schema provides. Baseline of 3 is appropriate when schema covers all 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 clearly states the tool adds a transport item (listing types) or flight to a trip, with a specific verb and resource. It distinguishes itself from trip_item_add by explicitly naming it as the alternative, so an agent can select it correctly without ambiguity.

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

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

The description gives explicit guidance: 'ALWAYS use this instead of trip_item_add for transport', which is a strong directive. It also mentions that origin and destination are required for correct map display, providing context on when to use it. However, it doesn't explicitly state when NOT to use it (e.g., for non-transport items), though the ALWAYS note effectively covers that.

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

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

Annotations declare readOnlyHint=false and destructiveHint=false, so the description does not contradict them. However, the description adds no behavioral context beyond the annotations: it does not disclose whether this is a partial update (PATCH-like) or full replacement, whether updating status has side effects (e.g., cascading to items), or whether destination coordinates are required together. For a mutation tool with 11 parameters, this is a significant gap.

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

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

The description is a single short sentence with no wasted words, which is efficient. However, it is under-specified: it earns its place but does not carry enough information to be genuinely helpful. It is concise but not structured to front-load any differentiating 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 mutation tool with 11 parameters, no output schema, and no usage guidance, the description is incomplete. The schema covers parameter formats, but the description does not explain the update semantics, partial-update behavior, or any constraints. An agent could call it correctly from the schema alone, but it would not know the behavioral implications or when to prefer it over sibling update 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 the schema already documents all 11 parameters. The description adds no additional meaning beyond the schema, which is acceptable per the baseline. However, it does not clarify relationships between parameters (e.g., whether destinationLat/destinationLng must be set together, or whether startDate/endDate have ordering constraints).

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 trip details' uses a clear verb and resource, but it is generic and does not distinguish this tool from the many other trip_* update tools in the sibling list (e.g., trip_item_update, trip_task_update, trip_note_update). It states what it does at a basic level but lacks specificity about which trip-level fields are affected.

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

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

No guidance is provided about when to use this tool versus alternatives. The description does not mention that this is for top-level trip fields (name, status, dates, budget, destination) as opposed to trip items, tasks, notes, or locations. An agent must infer usage from the parameter names alone.

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