Award Travel Finder

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

With all annotation hints false, the description carries the burden of behavioral disclosure. It discloses the paid nature, the cost allocation rule across legs, and Gmail integration. It does not cover failure modes or idempotency, but the essential side effects (logging and cost distribution) are transparent.

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

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

The description is a single coherent paragraph with no fluff. Each sentence adds value: purpose, award/cash distinction, multi-leg handling, Gmail hint, and paid warning. It front-loads the core action and methodically covers important edge 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?

Given 18 parameters, 5 required, and no output schema, the description covers the critical semantics needed to log a booking correctly, especially the multi-leg and award/cash nuances. It doesn't explain every optional parameter or return behavior, but for a logging tool with clear schema patterns, it is sufficiently complete for its complexity.

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

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

Schema coverage is only 39%, so the description must compensate. It clarifies the meaning of kind (award vs cash with example), trip_id's role in multi-leg grouping, and the first-leg cost rule for cash_paid and points_spent. It also hints at taxes_currency via the cash_paid description. Key parameters are well explained, though many optional ones (notes, passengers, confirmation_number) are left to the schema.

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

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

The description clearly states the tool logs a flight booking/redemption, distinguishes award vs cash, and explains the multi-leg handling pattern. It explicitly names the alternate payment kinds and the per-leg call convention, making its purpose distinct from update/delete/list flight booking 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?

Provides explicit when-to-use guidance for multi-leg trips (call once per leg with same trip_id, put total cost on first leg), and mentions Gmail integration and paid feature. It does not explicitly contrast with update_flight_booking or when to modify existing bookings, but the core usage context is clear.

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: award bookings include price-drop monitoring, cash bookings require kind and original_pay_rate_usd, and trip_id causes the stay to group with matching flights. It also discloses that this is a paid feature. No contradiction with annotations exists.

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

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

Four sentences convey the core purpose, parameter-critical guidance, workflow context, and a paid-feature warning without redundancy. The most important information, the award/cash distinction, is front-loaded, and every clause adds 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 12-parameter creation tool with no output schema and annotations that only report false hints, this description covers the essential workflow well: where IDs come from, required cash parameters, trip grouping, and email-based data extraction. It does not describe return values or duplicate-handling behavior, but the core call path is clear enough for an agent to proceed 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 coverage is only 50%, and the description compensates well for key gaps. It explains the award vs cash distinction for kind, the source of hotel_id, the purpose of trip_id, and how check-in/out dates, room type, rate, and confirmation number can be extracted from a Gmail reservation.

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: log a hotel booking to the user's portfolio. It clearly distinguishes this from sibling tools like add_flight_booking, update_hotel_booking, and delete_hotel_booking by stating the operation type and target resource explicitly.

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

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

It gives concrete sourcing guidance: use hotel_id from search_hotels or get_hotel_availability results. It also explains when to pass trip_id and how that affects grouping with flights. It does not explicitly name alternatives like update_hotel_booking for modifications, but the context strongly implies the intended workflow.

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

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

Annotations are all false, giving no safety hints, so the description carries the burden. It states this is a mutation ('Add') but does not disclose side effects, idempotency, failure modes, or what happens if the voucher already exists. The paid note and the prerequisite add some context but not rich behavioral detail; a 3 is appropriate.

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 filler. The core purpose is front-loaded, the prerequisite is given, and the paid caveat is included. 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?

For a simple add operation with one required parameter and no output schema, the description covers the essential workflow: what to do, how to get the slug, and that it costs money. Missing details like error handling or return values are minor given the simplicity and the well-specified 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 75% (3 of 4 params have descriptions including format and examples). The description text adds only the instruction to use list_voucher_types to get the slug, which reinforces the schema rather than adding new meaning. With high schema coverage, baseline 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 clearly states the action (Add), the resource (companion/upgrade voucher), and the destination (user's inventory). It also distinguishes itself from siblings like 'apply_voucher_to_booking' and 'delete_voucher' by specifying the inventory add purpose, and mentions the prerequisite 'list_voucher_types' for finding the required slug.

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 a concrete prerequisite ('Use list_voucher_types to find the voucher_slug') and explicitly flags it as a paid feature, giving the agent an important usage constraint. However, it does not explicitly state when not to use it or list alternative tools (e.g., 'apply_voucher_to_booking'), so it falls short of full exclusions.

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 provide no hints (all false), so the description bears the full burden. It discloses that the tool can apply or detach a voucher and that it is a paid feature, but does not mention side effects such as reversibility, impact on the booking, or error conditions. For a mutation tool with zero annotation coverage, this is a moderate but incomplete disclosure.

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

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

The description is two sentences, front-loaded with the primary action and followed by the detach condition and paid-feature note. There is no fluff or repetition; every clause contributes to understanding the tool's purpose.

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

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

For a relatively simple mutation with 3 parameters and no output schema, the description covers the core use cases: applying and detaching, with examples and a cost condition. It lacks explicit handling of error cases or return values, but those are not always required. The description is mostly complete for an agent to decide when and how to invoke 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?

Schema description coverage is 100%, so the schema already explains all parameters. The description adds some nuance with examples (voucher types) and reiterates the detach behavior for booking_id, but this is largely redundant with the schema. It does not provide additional meaning beyond what the schema offers, 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 clearly states the action 'apply' and the resource 'voucher to a booking', with specific examples (BA companion voucher, Barclaycard upgrade voucher) that differentiate it from generic booking tools. It also distinguishes from sibling tools like add_voucher or delete_voucher by specifying it affects existing bookings. The mention of 'detach' further clarifies its dual purpose.

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

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

The description implies when to use it: when you have a held voucher and want to attach it to a booking or detach it. It gives context with examples and notes it is a paid feature, which is a use condition. However, it does not explicitly compare to alternatives like add_voucher or list_my_vouchers, though the distinction is implied by the tool name and sibling set.

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 establish that this is a mutating, non-destructive operation. The description adds context that it groups existing bookings under a trip and affects portfolio display. It does not disclose what happens if a booking is already assigned to another trip, nor any other side effects, but the annotations cover the main safety profile.

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: purpose, ID sourcing, and optional-parameter handling. The most important information is front-loaded, and there is no redundancy or filler.

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

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

For a three-parameter mutation tool with complete schema descriptions and non-destructive annotations, the description covers the essentials: what the tool does, where to get IDs, and how to treat optional arrays. It is slightly incomplete about reassignment behavior and whether calling again with the same bookings has any effect, but nothing blocks an agent from invoking it correctly.

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

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

Schema coverage is 100%, yet the description still adds real value by explaining how to source each parameter's values and by clarifying that empty arrays or omission are acceptable for unused booking types. This directly informs correct parameter construction beyond the schema's terse 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: "File existing flight and/or hotel bookings under a workspace Trip." It also states the outcome, grouping bookings in the portfolio, which clearly differentiates this tool from adding new bookings or creating trips. The scope is unambiguous.

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

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

The description tells the agent where to get the required IDs: trip id from list_trips / create_trip and booking ids from list_flight_bookings / list_hotel_bookings. It also explains how to handle booking types being moved versus omitted. It does not explicitly name sibling alternatives or exclusion conditions, so it stops short of a 5.

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 frames the operation as a read-only audit that 'returns' a finding list, but the annotations include destructiveHint=true. No destructive behavior, side effect, or required authorization is disclosed, and the description directly conflicts with the destructive hint.

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 brief sentences, each carrying distinct information: purpose, chain coverage, and output. 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?

With no output schema and no parameter descriptions, the tool definition leaves important gaps: expected folio_text input format, how the finding list is structured, meaning of stay_type, and resolution of the conflicting destructiveHint annotation. It is not complete enough for an agent to confidently invoke the 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 0%, so the description must compensate, but it only helps with chain (by naming supported brands) and gives minimal context for folio_text. It does not explain stay_type, status_tier, confirmation_number, or the expected format of folio_text.

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

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

The description names a specific verb ('Audit'), a specific resource ('hotel folio'), and a clear purpose ('commonly-disputable charges'). It also distinguishes itself from the sibling audit_marriott_folio by explicitly supporting Marriott, Hilton, Hyatt, and IHG.

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 supported chains imply the tool's coverage, but no explicit when-to-use or when-not-to-use guidance is given. It does not mention alternatives such as audit_marriott_folio or state when each should be preferred.

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

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

Annotations already declare readOnlyHint and destructiveHint (which are contradictory), and the description adds context about specific charge types and the output. However, it does not disclose any side effects, authentication needs, or rate limits, and the description's 'audit' nature aligns with read-only without explicitly disclaiming destructive 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 three short sentences with no unnecessary words, front-loaded with the primary action and then the output and tier. It is concise and well-structured.

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

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

Given no output schema, the description should explain the return structure and required inputs. It only vaguely states it returns a finding list and dispute template, without detailing those structures. It also does not clarify the format for folio_text or how parameters like status_tier affect auditing. The specific charge types provide some context but not enough for full agent guidance.

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

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

Schema description coverage is 0%, so the description must compensate. The description does not explain any of the four parameters; it only hints at the relevance of stay_type by mentioning resort fees on award stays, but does not define how to use folio_text, status_tier, or confirmation_number. This leaves parameter meaning largely unexplained.

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 (Audit) and resource (Marriott Bonvoy folio) and lists specific charge types it checks (resort fee on award stays, parking double-billing, etc.), which clearly distinguishes it from the generic sibling audit_hotel_folio. It also mentions the output (finding list with dispute template), leaving no ambiguity about its function.

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

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

The description implies usage for Marriott Bonvoy folios by naming the brand, but it does not explicitly state when to prefer this tool over the generic audit_hotel_folio or any exclusions. There is no mention of alternative tools or conditions for use, so guidance is only implicit.

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

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

The description frames the tool as a read-only estimation ('Estimate', 'Answers'), matching readOnlyHint, but the annotations also set destructiveHint: true. The description does not disclose any destructive behavior, and 'estimate' directly conflicts with the destructive hint, so the agent receives contradictory signals.

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 front-loaded with purpose, followed by examples and operational rules. It is moderately sized and each sentence adds information, though the example questions are slightly redundant with the initial purpose statement.

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

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

For a 7-parameter calculator with no output schema, the description explains the return values (points plus great-circle distance), the program-specific calculation basis, and required program slugs. It does not describe the exact response shape or error conditions, but it is sufficient for 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 coverage is 100%, so the baseline is 3. The description adds real cross-parameter meaning: fare_price is only needed for revenue-based BA/AA earnings, while Flying Blue XP is segment- and cabin-based, clarifying when to supply fare_price and how segments factor in.

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 ('Estimate') with a precise resource (elite-qualifying points plus great-circle distance), names the three supported programs, and gives concrete example questions. This clearly distinguishes it from siblings like get_points_valuation or get_earning_rates.

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 example questions ('how many tier points is LHR–JFK in business?') and program-specific earning rules imply when the tool should be used. However, it does not explicitly say when to prefer it over alternatives such as get_earning_rates or when not to use it.

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

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

The description goes well beyond the annotations by adding specific post-invocation behavior: 'Cancelled monitors stop firing but are preserved for history.' This clarifies that despite destructiveHint=true, the data is not deleted and remains available historically. This is valuable context that the annotations alone do not 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?

Two short sentences with no filler. The action is front-loaded and the key behavioral nuance about preservation is stated as a separate clarifying clause. 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?

For a single-parameter mutation tool with no output schema, the description covers the precondition (active), the action (cancel by ID), and the outcome (stops firing, preserved). It is nearly complete, though it could have mentioned how to discover the monitor_id via list_route_monitors or what happens for unknown IDs.

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?

With 0% schema description coverage, the description is the only source of parameter meaning, but it only says 'by ID.' It does not explain where monitor_id comes from, what constitutes a valid monitor_id, or what happens if an invalid or already-cancelled ID is supplied. This leaves the agent to infer too much for the sole 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 ('Cancel') and names the precise resource ('route monitor'), with an explicit identifying scope ('by ID'). It also differentiates the behavior from related sibling tools by explaining that cancelled monitors stop firing but remain preserved, making it distinct from a delete operation or an update.

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 'active route monitor' establishes a clear precondition, and the consequence 'stop firing' explains what happens after the call. However, it does not explicitly mention alternatives, such as using update_route_monitor to modify a monitor or list_route_monitors to find a monitor ID, leaving some routing to the agent implicit.

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

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

The annotations say destructiveHint=true, but the description adds a valuable nuance: the record and its last result are preserved. This clarifies the real impact of the cancellation beyond the generic destructive hint and helps the agent set expectations.

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 convey the action, the consequence, and the retention behavior with no filler. 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 a simple one-parameter cancellation action, the description tells the agent what happens and what is preserved. It could mention error behavior or the source of the ID, but the tool's low complexity makes the definition 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?

The single parameter standing_order_id is mentioned indirectly through 'by ID', but the description adds little beyond the schema's property name and type. With 0% schema description coverage, there is minimal compensation, though the parameter is simple and self-explanatory.

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 ('Stop') with a clear resource ('standing order by ID') and states the outcome ('so it no longer runs'). It also clarifies the record is retained, which distinguishes it from deletion tools and other standing-order operations.

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

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

The description implies the right context: use this when you want a standing order to stop running but still keep its history. However, it does not explicitly name alternatives like list_standing_orders or explain when not to use this tool, leaving some inference to the agent.

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

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

The description's language suggests a read-only analysis ('estimate', 'rank'), but the annotations include destructiveHint=true alongside readOnlyHint=true, creating an unresolved tension. The description does not clarify whether the tool has any side effects or what destructive behavior might exist, and it adds only output composition rather than 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, compact sentence that front-loads the required input and clearly states the purpose and a key output detail. There is no filler, and every clause contributes useful information.

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

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

The input shape is documented by the schema, and the description conveys that output ranks cards and includes net annual fee after benefit credits. However, there is no output schema and the description does not specify ranking order, annualization assumptions, or how region/card_type affect results, leaving meaningful gaps for an agent.

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

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

Schema description coverage is 75%, so the schema already covers limit, region, and monthly_spending; the description adds no parameter-level detail. card_type remains undocumented in both the schema and the description, though its enum values are self-explanatory. This is an adequate but not compensating score.

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

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

The description clearly states a specific operation: estimate annual rewards for each card and rank them, based on a monthly spending breakdown. It also notes the output includes net annual fee after benefit credits. It does not explicitly name sibling alternatives, so it stops short of full explicit differentiation, but the purpose is unambiguous.

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

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

The description implies when to use the tool: when the user has a monthly spending breakdown and wants card reward estimates. It does not provide explicit when-not-to-use guidance or point to sibling tools such as cards_rank_welcome_bonuses or cards_compare_cards for different card-ranking tasks.

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 destructiveHint=true, which conflicts with the read-only nature of 'Compare' (a pure lookup/reporting operation). The description does not address this contradiction, and also fails to note the openWorldHint (results may not be exhaustive). This is a serious inconsistency that could mislead an agent into thinking calling it mutates state.

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

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

One concise sentence with no filler. The purpose and the comparison dimensions are front-loaded, and the sourcing hint is appended without bloat. Every phrase earns its place.

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

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

For a simple 1-parameter tool with no output schema, the description covers what it compares and where to get the IDs. It does not specify the return format, but that is a minor gap given the low complexity. The only significant omission is the behavioral contradiction, which is already penalized in its own dimension.

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 'ids' parameter, which already explains it expects an array of card IDs with examples. The description adds the pointer to list_cards as a source of valid IDs, which is helpful but not essential—the schema already does the heavy lifting. Baseline 3 is appropriate.

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

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

The description states a specific verb 'Compare' + resource 'cards' and enumerates the comparison dimensions (annual fees, welcome bonuses, top multipliers, total benefit credits). It clearly distinguishes this from siblings like cards_list_cards (just lists) and cards_get_card (single card detail), leaving no ambiguity about what the tool does.

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 'Pass card ids from list_cards' gives a concrete source for the input and implies when to use it (comparing 2–4 cards). It does not explicitly list exclusions or alternatives, but the guidance is actionable and sufficient for an agent to select this tool over 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?

Annotation Contradiction: The description uses read-only language ('Find', 'Returns cards sorted by multiplier descending'), but the annotations mark destructiveHint=true. The description does not acknowledge or explain any destructive behavior, creating a direct conflict between its implied behavior and the annotation.

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

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

Two concise sentences convey the core purpose, examples, and output ordering with no filler. Every phrase earns its place, and key information is front-loaded in the first sentence.

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 captures the essential search intent and sort behavior, but with no output schema it omits return structure details, default limit behavior, and filtering semantics for region and card_type. The conflicting destructiveHint annotation also leaves the tool's side effects ambiguous, reducing completeness.

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

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

Schema description coverage is 60%, leaving 'region' and 'card_type' without parameter-level descriptions. The description adds useful context about category examples and sorting by multiplier, but does not explain how region or card_type affect the results, so it only partially compensates for the schema gaps.

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 ('Find cards'), a specific resource ('cards'), and a precise selection criterion ('best earning multiplier for a spend category'), with concrete examples and a defined sort order. This clearly distinguishes it from sibling card tools like cards_list_cards or cards_compare_cards.

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 clearly communicates the intended use case: find the best card multiplier for a category like dining or groceries. It does not explicitly mention when not to use it or name alternatives, but the context is clear enough for an agent to route to it appropriately.

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 says 'Find' which aligns with readOnlyHint=true, and the tool is clearly a query operation. However, it adds no behavioral context beyond the annotations, and the annotations contain an internal conflict (readOnlyHint=true and destructiveHint=true) that the description does not help resolve.

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. The primary purpose is stated first, and the optional filter is placed second. Every word contributes meaning, 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 read-only lookup with fully documented parameters, the description conveys enough to understand the tool's purpose and basic optionality. The lack of an output schema is compensated by the natural implication that the tool returns a list of transfer programs, though a brief note about result format or comprehensiveness would have earned a 5.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds minimal value: 'airline or hotel' echoes the schema's partner_name example, and 'locally relevant' loosely paraphrases the region filter. It does not materially enrich parameter understanding.

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 ('Find') and identifies the resource: transferable points programs that transfer to a given airline or hotel. It is clear, but it does not explicitly differentiate from nearby siblings like cards_list_transfer_partners or find_transfer_paths, so it falls short of a fully distinguishing definition.

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

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

The description implies the use case: find transfer programs for a specific airline/hotel, optionally narrowed by region. However, it provides no explicit guidance about when to choose this tool over sibling alternatives such as cards_list_transfer_partners, compare_transfer_options, or get_program_partner_chart.

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 says 'Get full details' which clearly indicates a read-only, non-destructive operation, but the annotations declare destructiveHint=true. This direct contradiction between the description and annotations means the agent cannot trust the safety profile of the tool. The description does not add any behavioral context beyond the annotations, and the conflict makes this severely deficient.

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 lists the specific information returned. There is no unnecessary verbosity or filler; every word contributes to clarity.

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

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

With no output schema, the description usefully enumerates the returned data (multipliers, benefits, welcome bonus, source URL), giving an agent a clear expectation of the response. The required parameter is fully covered in the schema. The only gap is the unresolved contradiction with the destructiveHint annotation, but that affects trust more than invocation completeness.

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

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

The schema provides 100% coverage for the single 'id' parameter, including an example ('amex-gold-us') and a directive to use list_cards to discover ids. The description adds no additional 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 clearly states the tool's purpose: 'Get full details for a single card' with a specific resource (card) and lists the exact data points included (multipliers, benefits, welcome bonus, source URL). This distinguishes it from sibling tools like cards_list_cards (which would return a list) and cards_compare_cards (which compares multiple cards).

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

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

The description implies usage when full details of a specific card are needed, but it does not explicitly state when to use it over alternatives or provide exclusions. It does not reference any sibling tools or mention scenarios where 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?

Annotation Contradiction: annotations declare destructiveHint=true, but the description describes a read-only listing operation. The description does not reconcile this conflict; it simply says 'List...', which contradicts the destructive hint and undermines the agent's ability to predict 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?

Three sentences, front-loaded verb and resource, and every sentence earns its place by stating scope, return shape, and the get_card alternative.

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 largely complete for a simple list tool: it names the output fields and tells the agent where to get full details. It lacks pagination/limit guidance and does not clarify the annotation conflict, so not a perfect 5.

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 have 100% schema description coverage with enum values and descriptions, so the schema carries the semantic burden. The description adds no further parameter detail, but the baseline 3 applies.

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

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

States a specific verb and resource: 'List credit cards in the database.' It also distinguishes itself from the sibling get_card by noting it returns compact summaries and directing to get_card for full details.

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

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

Explicitly routes to get_card when full details are needed, which is a clear alternative. It does not, however, state when this tool should not be used or mention the optional filters as selection 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?

The description characterizes the tool as a read-only listing operation ('List recent card data changes'), which directly contradicts the annotation destructiveHint: true. Although it aligns with readOnlyHint: true, the conflicting destructiveHint creates an irreconcilable contradiction that the description does not resolve or acknowledge.

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 zero redundancy. The core action and resource are front-loaded, examples clarify scope, and the usage prompt is concise. 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?

Given the contradictory annotations (readOnlyHint true vs destructiveHint true), the description is not fully contextually complete because it leaves the destructive annotation unaddressed, potentially confusing an agent. The description itself is clear for a simple list tool, but the surrounding annotation conflict reduces overall completeness.

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

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

Schema description coverage is 100%, with each parameter (days, limit, card_id) already documented in the input schema. The description adds no parameter-level detail beyond the schema, 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 and resource: 'List recent card data changes,' and provides concrete examples (welcome bonus updates, fee changes, multiplier edits). This clearly distinguishes it from sibling tools like cards_list_cards and cards_get_card, which focus on the cards themselves rather than their change history.

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 frames the tool's intended use case: 'Useful for "what changed recently?" queries.' This gives clear context for when to invoke it. It does not name exclusions or alternatives, but for a simple read-only listing tool, the context is sufficient.

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?

Annotation contradiction: the annotations include both readOnlyHint=true and destructiveHint=true, while the description describes a plain listing operation. A read-only list is not destructive, so the description contradicts the destructiveHint annotation. The description also provides no extra behavioral context such as pagination, ordering, or 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?

Two sentences with no filler. The verb and object are front-loaded, and the region example earns its place by clarifying behavior beyond the schema.

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

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

The description covers the main function and the region filter, but it does not state default behavior when no filters are supplied, describe the return shape, or disambiguate from closely related sibling tools. Given there is no output schema and the annotations are internally inconsistent, these are meaningful gaps.

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

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

The description adds useful meaning for the region parameter by explaining that region limits results to market-relevant programs and giving a concrete example. The other two parameters are already reasonably covered by the schema (region and provider have descriptions; partner_type has an enum), so the description does not need to compensate heavily.

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 specific resource ('transferable points programs and their airline/hotel partners'), making the core purpose immediately clear. It does not explicitly differentiate from overlapping siblings such as cards_find_transfer_programs_for_airline or get_program_partner_chart, so it stops short of a full 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 description gives no guidance about when to choose this tool over the many related transfer/partner tools in the sibling list. The main usage clue it provides is parameter-level behavior for region ('Region filter shows programs relevant to that market'), which does not help with tool selection.

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

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

The description says 'List current welcome bonuses,' which is clearly a read-only operation, yet annotations include destructiveHint: true. This directly contradicts the description and creates agent confusion about whether the tool can destroy data. The description also adds no additional behavioral context such as data freshness or rate limits.

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 tight sentence front-loads the core purpose and sort order, then adds the optional filter. There is no filler or redundant restating of the tool name.

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 plus schema covers the essential invocation details: what is returned, sort order, and optional filters are mostly understandable. However, there is no output schema and the description does not mention return fields, nor does it call out region/card_type filtering despite those being available parameters.

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 descriptions already cover limit, min_value, and monthly_spend, and enum values make region and card_type self-explanatory. The description contributes only the 'spend achievability' framing for monthly_spend, which is mild added meaning but not essential given 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 ('List') with a clear resource ('current welcome bonuses') and adds distinguishing context: sorted by point/mile value descending. This clearly separates it from sibling tools like cards_list_cards or cards_compare_cards.

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 the agent needs current welcome bonuses ranked by value, with an optional spend achievability filter. However, it does not explicitly name alternatives or state when not to use this tool, leaving some routing judgment to the agent.

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

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

Annotations include readOnlyHint=true and destructiveHint=true, which are contradictory. The description does not address whether the tool has any side effects, but it aligns with the read-only implication ('ranks', no mutation). However, it adds no extra behavioral context and leaves the destructiveHint unresolved. Given the contradictory annotations, the description fails to clarify behavior 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?

The description is two sentences, front-loaded with the core decision context and then details of what the ranking includes. It is free of fluff and efficiently communicates the tool's scope and output. The 'Premium tier' note, while extra, is info about availability, not noise.

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 ranking tool with no output schema, the description clearly states the ranking criterion (cents-per-point), the elements considered (multi-hop, bonuses, posting times), and the input context. It lacks explicit mention of how results are presented or any limitations, but given the tool's focused scope, it covers most essential aspects for an agent to invoke it correctly.

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

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

Schema coverage is 100% with descriptions for both parameters. The description restates the purpose ('Given a target loyalty program and how many points it costs') but does not add new syntactic or semantic details beyond what the schema already provides. It gives context but no additional parameter guidance, so baseline 3 applies.

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

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

The description clearly states that the tool ranks transfer routes for a specific redemption, including multi-hop routes, bonuses, and posting times. It specifies the resource (points for a redemption) and the verb (decide/rank). However, it does not explicitly differentiate from sibling tools like find_transfer_paths or recommend_redemption, though the scope ('from the user's own balances') is distinctive.

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

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

The description gives no explicit guidance on when to use this tool versus alternatives. It does not mention exclusions, prerequisites, or mention that it is for comparing options when a specific redemption is planned. The usage context is only implied by the description's content, not 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?

Beyond what the annotations state, the description reveals that the tool alone does not complete the connection: it returns a URL the user must open in a browser to grant access. It also discloses the initiating side effect and the dependency on a connection_required state.

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

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

Three short, purposeful sentences: action and resource, return value/user step, and trigger condition. There is no redundant or filler content.

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

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

For a one-parameter tool with no output schema, the description covers the invocation trigger, the return value, and the required user action. An agent has what it needs to call 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%, and the single provider parameter already has an enum and a description. The tool description adds no meaningful parameter semantics beyond the schema, so baseline 3 applies.

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

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

The description opens with a specific action ('Initiate the OAuth flow') and a clear resource ('external integration'), and states it returns the authorize URL. This clearly distinguishes it from sibling tools like disconnect_integration and list_integrations.

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 gives a trigger condition: 'Use this when a tool returns connection_required.' This is strong context, but it does not mention when not to use the tool or name alternatives such as disconnect_integration or list_integrations.

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 useful behavioral details beyond that: checks run every 12 hours, emails are sent on fresh availability, and account tier limits apply. It does not cover every side effect, but it meaningfully discloses the most important background 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?

Three compact sentences, each earning its place: the core action, the monitoring behavior, and the account limitation. The key action is front-loaded, 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 gives the essential behavioral and limitation context but omits several practical details: what the tool returns, how a user would later update or cancel the monitor, duplicate handling, and what counts as 'fresh availability.' Given there is no output schema and no annotation detail beyond the hints, an agent might still need to infer or ask about these points.

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 only 25%, so the description carries some burden. It adds meaning by mapping the key parameters to 'route + window + cabin,' which covers origin, destination, earliest_date, latest_date, and cabin. However, it does not mention the optional airlines, max_points, or passengers parameters, leaving part of the low-coverage schema uncompensated.

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: 'Create a saved route monitor.' It then clarifies the monitor's purpose—checking award seats by route, date window, and cabin—making it clearly distinct from sibling tools like list_route_monitors, cancel_route_monitor, and fs_create_seat_alert.

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

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

The description implies when to use this tool: when the user wants ongoing monitoring of award availability rather than a one-time search. However, it does not explicitly name alternatives or state when not to use it, such as pointing users to search_availability for immediate checks or update_route_monitor for changes.

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 the sparse annotation block, the description discloses meaningful behaviors: the order runs unattended, the result is emailed, the prompt executes with no conversation history, and the feature is Premium-only. These are exactly the operational constraints an agent needs and the annotations alone do not 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 front-loaded with the core action and then uses two illustrative examples that directly clarify the prompt requirement. Every sentence earns its place, and the 'Premium only' restriction is included without padding.

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 creation tool with 5 parameters and no output schema, it covers the essential context: what the order does, how the result is delivered, prompt requirements, and access restriction. It does not describe the immediate API return value, which would have made it fully complete.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value on top by explaining how to write the required prompt: complete, self-contained, explicitly naming routes/programmes/cabins/dates. This is genuinely useful guidance beyond the schema's short 'self-contained instruction' note.

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

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

The description clearly states the action ('Save a recurring instruction'), the resource (a standing order ATF runs), and the behavior ('then emails the result'). It is easily distinguished from siblings like cancel_standing_order and list_standing_orders by focusing on creation and the recurring, unattended execution model.

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 gives clear usage context: 'Use for anything the user wants checked repeatedly without asking', plus two concrete examples that help an agent recognize the right scenario. It does not explicitly name alternatives or state when not to use it, so it stops short of a 5.

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 a non-read-only, non-idempotent mutation. The description adds useful behavioral context by explaining what a trip contains and the active-trip limit. It does not disclose what happens when the limit is exceeded, whether duplicate names are allowed, or what the response will look like.

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

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

The description is a single concise sentence. It front-loads the action, gives a compact clarifying definition, and includes a relevant account-limit caveat with no redundant wording.

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 operation without an output schema, the description explains the resource and one business rule. Still, it omits the return value, failure behavior when the active-trip limit is hit, and how this tool relates to post-creation steps such as assign_bookings_to_trip.

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 only 50%, with start_date and end_date lacking descriptions. The tool description does not compensate by explaining any parameters; it only clarifies the trip concept and account limit. Name and destination are described in the schema, but the date parameters receive no added semantic guidance.

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: 'Create a new trip', and defines the resource as 'a project workspace grouping chats, searches, monitors, and bookings.' This definition distinguishes create_trip from related siblings like list_trips, delete_trip, and plan_trip.

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

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

The description implies when to use the tool—when a new project workspace is needed—and adds a concrete constraint about free accounts having one active trip with extra trips requiring Premium. However, it does not explicitly mention alternatives or conditions where another tool should be used instead.

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 destructiveHint=true and readOnlyHint=false; the description adds the trigger scenarios and the 'tracked' qualifier. It does not disclose side effects (e.g., impact on trips, reversibility), so it adds modest value beyond 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, no fluff, action first then usage conditions. Every phrase carries information.

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

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

The tool is simple (one required param, no output schema), and the description covers what triggers it and what it acts on. It omits side effects or confirmation behavior, but the destructive annotation partially covers the risk profile.

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

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

Schema description coverage is 0%, so the description needed to explain how to identify the booking, but it never mentions booking_id or provides any additional parameter context. The single parameter is only documented by its name and integer type.

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

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

States the specific operation (cancel/remove) and resource (tracked flight booking), with concrete trigger examples ('cancelled, superseded, no longer happening'). Clearly distinguishable from sibling delete_hotel_booking or delete_trip.

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

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

Provides explicit user-intent conditions ('when the user says...') that trigger this tool. Does not name alternatives or exclusions, so not a full 5, but the guidance is clear and actionable.

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 description is not required to restate the destructive nature. It adds some context ('tracked', 'portfolio') and the reason for use, but does not disclose additional behavioral traits such as irreversibility, cascading effects, or success/return 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?

Two short sentences convey both the operation and the usage context with no filler. The core action is front-loaded, and every clause earns its place.

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

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

For a single-parameter destructive tool with clear annotations, the description covers purpose, target, and usage scenarios. It does not specify side effects on related trips or bookings, but that level of detail is not essential for invoking this tool correctly given its simplicity and the annotation profile.

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

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

Schema description coverage is 0%, so the description carries the burden of explaining booking_id. It never explicitly mentions the parameter, how to obtain it, or what it references beyond the general notion of a 'tracked hotel booking.' The property name and integer minimum do some work, but the description fails to compensate for the missing 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 ('Remove') with a clear resource ('tracked hotel booking') and scope ('from the user's portfolio'). This clearly distinguishes it from related siblings like delete_flight_booking or delete_trip, and the first sentence fully states the operation.

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 to use it: 'when the trip is cancelled or the booking was added by mistake.' It does not explicitly name alternatives or exclusion cases, but for a single-purpose delete tool tied to one resource, the usage context is clear and sufficient.

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 mark destructiveHint=true, so the destructive nature is known. The description adds useful context beyond annotations: it is a 'Paid feature' (cost/authorization implication) and only affects visits the user logged, not shared records. It does not detail irreversibility, but that is already signaled by destructiveHint.

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

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

Three short sentences, each contributing: the action, how to find the id, and the paid-feature caveat. No filler or restatement of the tool name.

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 with no output schema, the description plus annotations fully equip the agent: it names the action, the source of the id, the prerequisite, and the paid restriction. Nothing important appears missing 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 schema already describes visit_id as 'Id of the logged visit, from list_lounge_visits,' covering 100% of parameters. The description reinforces this by telling the agent to use list_lounge_visits to find the id, but adds no new semantic 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?

States a specific verb ('Remove') and resource ('lounge visit'), and ties it to a prior action ('previously logged with log_lounge_visit'), so an agent knows exactly what this tool does. It clearly distinguishes from logging and listing, though it doesn't address the similarly named sibling lounge_delete_visit.

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

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

Gives explicit instruction to call list_lounge_visits to obtain the visit_id, showing the prerequisite step. It also scopes usage to visits 'previously logged with log_lounge_visit,' implying it is not for arbitrary lounge records. However, it does not mention the near-duplicate sibling lounge_delete_visit or state when to prefer one over the other.

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, covering the safety profile. The description adds the context that the action targets a 'tracked' status and offers a concrete example, but does not elaborate on consequences (e.g., irreversibility, impact on related data). With annotations in place, this is acceptable but not 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 a single sentence that is front-loaded with the core action, includes a useful example, and contains no redundant words. It is appropriately concise and well-structured.

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

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

For a destructive operation with an undocumented parameter, the description is under-specified. The lack of any explanation of 'program' is a significant omission, and the description does not cover prerequisites or side effects, making it incomplete for safe and correct usage.

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

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

The schema has one required parameter 'program' with no description (coverage 0%). The description does not mention this parameter at all, providing no guidance on what values it expects (e.g., program name). The description completely fails to compensate for the schema gap, leaving the agent without essential information to call the tool correctly.

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 ('Remove') and resource ('a tracked elite/loyalty status'), and includes an example of when to use it ('when it lapses and the user doesn't want to renew it'). This unambiguously identifies the tool's purpose and distinguishes it from sibling tools like set_loyalty_status.

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

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

The description provides a specific usage scenario ('when it lapses...'), giving clear context for when to invoke the tool. However, it does not explicitly contrast with alternatives (e.g., 'use set_loyalty_status to add/update') or state when not to use it, missing an opportunity to fully differentiate 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?

Annotations already declare destructiveHint=true and readOnlyHint=false, so the destructive nature is covered. The description adds useful context like 'Paid feature' and real-world scenarios, but does not disclose what happens beyond the removal, such as whether the deletion is permanent or affects related data.

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 filler. The core action is stated first, followed by practical examples, the source for the parameter value, and the paid-feature warning. Every sentence earns its place.

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

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

For a simple one-parameter destructive tool with full schema coverage and annotations, the description covers what, when, how to identify the program, and the paid constraint. No output schema exists, so explaining return values is unnecessary.

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 schema already documents 'program' as the loyalty program name as shown by list_points_balances. The description mostly restates this same guidance, so it adds no significant new parameter meaning 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?

Description uses a specific verb 'Remove' and resource 'loyalty program from your points balances', immediately distinguishing it from updating or listing balances. The examples clarify exactly what kind of removal is intended.

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

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

Gives clear context on when to use the tool ('closed the account or added it by mistake') and tells the agent to reference list_points_balances for the program name. It does not explicitly mention when not to use it or point to update_points_balance as an alternative, so it stops short of a 5.

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 goes further by explaining that archiving keeps the trip and itinerary, and that bookings, monitors, and chats are always preserved and simply unfiled. It also clarifies that permanent deletion removes the itinerary for good, adding meaningful behavioral context 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 two sentences, front-loaded with the core purpose, and every clause adds decision-relevant information about the two deletion modes. There is no filler or redundant restating of the tool name.

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 tool with two modes, the description explains both outcomes and the fate of associated records, and the schema covers the parameters. It does not describe return values or error behavior, but with no output schema and only two simple parameters, it is largely 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 schema already documents both parameters fully, including the default false for permanently. The description reinforces the permanently semantics but adds little beyond what the input schema provides, 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 and resource ('Archive a trip, or delete it permanently') and clarifies the two modes. It does not explicitly differentiate from sibling deletion tools, but the trip scope is evident.

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 gives clear context for choosing between archiving and permanent deletion: archiving frees the active-trip slot while retaining the trip, while permanent deletion removes the trip and itinerary for good. It does not explicitly name alternatives or exclusion cases, so it falls short of a 5.

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 the description's 'remove' aligns with that. The description adds the scope 'from the user's inventory', which is useful, but it does not disclose permanence, side effects, or preconditions. This is acceptable given annotations cover the destructive 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?

A single, well-structured sentence. It is appropriately sized for the tool's simplicity and conveys the core action immediately without any filler.

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

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

For a single-parameter destructive tool with annotations covering the danger profile, this description is largely complete. An agent can infer the required voucher_id and the inventory scope. It lacks explicit mention of return behavior or failure modes, but those are not essential for this simple 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 0%, so the description carries the burden of parameter meaning. The description does not explain voucher_id, how to obtain it, or its role beyond the schema's property name and type. With only one self-explanatory parameter, the gap is minor, but the description does not compensate for the zero coverage.

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

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

The description uses a specific verb ('remove'), a clear resource ('voucher'), and a precise scope ('from the user's inventory'). This clearly distinguishes it from related siblings like add_voucher, list_my_vouchers, and apply_voucher_to_booking.

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, nor any exclusions (e.g., what happens if a voucher is already applied to a booking). The context of 'user's inventory' is implied but no explicit usage direction 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?

Although destructiveHint=true already signals danger, the description adds specific context about what is destroyed ('OAuth tokens are deleted from ATF storage'), which is exactly the kind of beyond-annotation detail needed. The wording also implies irreversibility.

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

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

Two short sentences with no filler, and the core verb and object are front-loaded. Every word contributes to understanding the tool's function.

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 tool with no output schema, the description plus annotations cover what the tool does, what it destroys, and the precondition for use. Nothing essential 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?

With 0% schema description coverage, the description carries some burden, but the single provider parameter is constrained and self-explanatory via the enum. The phrase 'previously connected integration' helps the agent select a provider that is already linked, which adds value over the raw 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 ('Revoke') and resource ('previously connected integration'), and adds that OAuth tokens are deleted, making the operation unambiguous. The contrast with sibling tools connect_integration and list_integrations is clear from the description itself.

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

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

'Previously connected' states the precondition for use and implies the tool should not be used for new integrations. It does not explicitly name alternatives, but the sibling set makes the distinction obvious.

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 presents the tool as purely informational ('Lists complementary remote MCPs... with one-line install URLs'), implying read-only behavior. This contradicts the provided annotation destructiveHint: true, which suggests the tool may cause destructive side effects. The description neither explains nor acknowledges this destructive potential, so it directly conflicts 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 front-loaded with the main purpose, then provides scope details and concrete usage triggers. It is efficient, though the first two sentences are slightly redundant ('Discover ... MCP servers' vs 'Lists complementary remote MCPs'), preventing a perfect score.

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 zero-parameter discovery tool, the description covers what the tool lists and when to call it. However, the unresolved destructiveHint annotation and the lack of any side-effect disclosure leave important context missing; an agent cannot safely assess whether invoking this tool may alter the client or environment.

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 zero parameters and 100% schema description coverage, so the description is not required to elaborate on parameter meaning. The baseline for zero-parameter tools is 4, and nothing here lowers that.

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 ('Discover') and a clear resource ('other flight & travel MCP servers'), and lists concrete coverage areas such as seatmaps, airport delays, and lounges. It does not explicitly differentiate itself from sibling tools like fs_discover_more_flight_tools or lounge_discover_more_flight_tools, so it falls 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 description provides explicit trigger examples ('seat selection, airport delays/security waits, baggage rankings, lounges, or "what other flight tools are there?"'), giving clear context for when to call the tool. It does not mention when not to use it or point to alternatives, though the trigger list is strong enough for a 4.

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 says the tool only 'Find[s]' hotels, implying read-only behavior, but the annotations declare destructiveHint=true. It also fails to reconcile that with the also-present readOnlyHint=true. This is a direct contradiction between the description and structured metadata.

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 compact and front-loads the action in the first sentence. The benefit details and usage trigger add useful context for intent matching without being verbose, though the benefits list is not strictly necessary.

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 two parameters are fully covered by the schema, and the tool is a simple read-style search. However, there is no output schema and the description does not clarify what the result shape is or address the contradictory destructiveHint, leaving some ambiguity.

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

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

Schema description coverage is 100%; both city and program are already fully documented. The description adds no further parameter-level meaning, but does not need to given the schema's clarity, 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 opens with a clear verb and resource: 'Find Amex Fine Hotels & Resorts (FHR), Amex The Hotel Collection (THC), or Chase Edit hotels in a city.' It identifies exactly what the tool returns and differentiates it from generic hotel search siblings by naming specific premium programs.

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 an explicit trigger: 'Use when the user wants premium hotel options that maximize portal stacking.' It does not, however, specify when not to use it or mention alternatives like search_hotels, so it stops short of a 5.

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 clearly frames the tool as a read-only lookup ('Find all transfer routes,' 'Surfaces,' 'computes'), but the annotations include destructiveHint: true alongside readOnlyHint: true. This is a serious contradiction that the description does not resolve, leaving an agent with conflicting signals about whether invoking the tool can mutate state.

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 three concise sentences with no filler: definition and example, key behavioral features, and usage condition. Important information is front-loaded and each sentence 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 definition plus fully described parameters gives the agent enough to invoke the tool correctly. With no output schema, the description could do slightly more to explain the shape of the returned routes, but it does state that source points are computed and that routes can include hotel-program hops.

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 from_program, target_program, max_hops, and points_needed. The description adds meaningful context by mentioning 'applies live transfer bonuses' and 'source points needed,' but it does not add parameter-level 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 states a specific verb and resource: 'Find all transfer routes (direct AND multi-hop) to move points from one program to another.' It includes a concrete example and clarifies that it surfaces 'non-obvious second-hop routes,' distinguishing it from simple partner-lookup 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 description gives an explicit usage condition: 'Use when a card/program has no direct partner with the target.' This tells the agent when to invoke it, though it does not name or contrast alternative sibling tools like compare_transfer_options or get_program_partner_chart.

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 states 'Create a seat alert', which is a write operation, yet the annotation readOnlyHint=true indicates the tool is read-only. This is a direct contradiction. The description also doesn't mention that it creates a persistent record that can later be deleted, nor does it clarify the destructiveHint=true annotation. Because the description contradicts the annotations, this dimension scores the minimum.

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 three sentences and front-loads the primary action. It efficiently covers the mechanism, preferences, auth, and a prerequisite condition. There is minimal redundancy, and the structure is logical. It earns a 4 for being concise and well-ordered, though not maximally concise.

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 omits what the tool returns after creation (no output schema) and doesn't clarify the write semantics, which is critical given the contradictory annotations. It also doesn't mention that alerts can overlap with existing ones or that deletion is possible. For a tool with conditional parameters and no output schema, the description is incomplete, especially regarding side effects.

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 descriptions for all 6 parameters (100% coverage), including conditional requirements like specific_seat and adjacent_seats_count. The description mentions example preferences (window, aisle, etc.) but adds no new semantic detail beyond what the schema already documents. At 100% schema coverage, the baseline is 3, and the description doesn't raise it.

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

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

The description clearly states the action (create a seat alert), the resource (seat alert for a flight), and the mechanism (email notification). It distinguishes itself from related siblings like fs_list_seat_alerts and fs_delete_seat_alert by focusing on the creation aspect, though it doesn't explicitly contrast with them. The purpose is unambiguous and specific.

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 a key usage guideline: the flight must already exist in the database, and points to the alternative search_flight if not. It also notes authentication is required. However, it doesn't explicitly state when not to use this tool (e.g., when only checking current alerts, use fs_list_seat_alerts), so it's clear but lacks explicit exclusions.

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 says 'Delete a seat alert,' a mutating/destructive operation, while annotations declare readOnlyHint: true. This directly contradicts the annotations. Although the description also mentions authentication, the contradiction is severe and makes the behavioral contract untrustworthy.

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

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

Two concise sentences with no filler. The core action is front-loaded, and the prerequisite and authentication note each add value without redundancy.

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

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

For a single-parameter destructive tool with no output schema, the description covers what, how to find the ID, and authentication. It is mostly complete, but the annotation contradiction undermines the overall context an agent would rely on.

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 alert_id parameter is already documented as 'ID of the seat alert to delete.' The description adds useful workflow context by telling the agent to use list_seat_alerts to discover that ID, going beyond the schema alone.

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: 'Delete a seat alert by its ID.' It clearly distinguishes this from sibling tools like fs_create_seat_alert and fs_list_seat_alerts by naming the exact operation and the key identifier needed.

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 instructs to use list_seat_alerts to find the alert ID, providing a clear prerequisite step. It does not explicitly state when not to use this tool or name alternative sibling tools, but for a simple delete operation this is acceptable 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?

The description says the tool only 'Lists' complementary MCPs, implying a read-only operation, but annotations include destructiveHint=true. This conflicts with the description and leaves the agent uncertain whether the tool can have side effects; no clarification is offered. The presence of readOnlyHint=true alongside destructiveHint=true makes the ambiguity worse.

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 no redundant filler. It front-loads the core action and resource, then adds concrete category examples that make the tool's value immediately understandable.

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 no-parameter discovery tool, the description gives enough operational context, but it lacks an explicit statement of the return format or follow-up actions. More importantly, it does not resolve the destructiveHint conflict, leaving an important behavioral ambiguity unresolved.

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 is an empty object with 100% coverage, so there are no parameters requiring semantic explanation. The description adds no parameter detail, but none is needed; the baseline for a zero-parameter tool 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 tool's purpose with 'Discover' and 'Lists' plus the resource: other flight & travel MCP servers, including specific categories like award flights, delays/wait times, and lounges. However, it doesn't distinguish itself from similarly named siblings such as discover_more_flight_tools or lounge_discover_more_flight_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 explicit guidance on when to use this tool versus alternatives, and no sibling tool is named. Given the large sibling list containing other discovery tools, an agent receives little help selecting this one.

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

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

The description implies a read-only lookup ('Find'), but the annotations include destructiveHint: true, which contradicts the described behavior. This creates serious ambiguity about whether the tool might alter state. The readOnlyHint: true also conflicts with destructiveHint: true, and the description does nothing to resolve this.

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 includes concrete output details. Every sentence earns its place with no redundant phrasing.

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 mentions the return type, which is helpful given no output schema. However, it omits ranking criteria, data freshness, and any clarification of the destructive annotation conflict. Given the similarity to several sibling tools and the annotation ambiguity, the description is minimally adequate but 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%, so the input schema already documents all parameters and enums. The description's examples of preferences (window, aisle, etc.) add little beyond the schema, 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 clearly states the verb ('Find'), the resource ('best available seats on a flight'), and the output ('ranked list' and 'interactive seatmap'). However, it does not explicitly differentiate from similar sibling tools like fs_interactive_seat_finder, fs_get_seatmap, or fs_search_flight, so it falls just short of full clarity.

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

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

The description implies the tool should be used when a user has seat preferences and wants ranked recommendations. However, it provides no explicit guidance on when to prefer this tool over the many similar flight tools, and no alternatives or exclusions are mentioned.

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 presents a read-only information lookup plus seatmap rendering, but the annotations include destructiveHint=true, directly contradicting the described behavior. Additionally, readOnlyHint=true conflicts with destructiveHint=true, and the description does not explain or address this destructive indication. This is an annotation contradiction.

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 concise sentences with the core purpose front-loaded and no filler. The second sentence adds a relevant behavioral detail about rendering the interactive seatmap.

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, yet the description does not specify the return shape, units for pricing, or what 'detailed information' concretely includes beyond a vague list. More importantly, the destructiveHint=true contradiction is left unresolved, creating a significant completeness gap for a supposedly read-only 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?

The input schema already documents all three parameters with descriptions and examples at 100% coverage. The description adds no parameter-level meaning beyond naming the seat and flight, so the baseline 3 is appropriate.

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

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

The description clearly states the verb ('Get detailed information') and the resource ('a specific seat on a flight'), including the kinds of data returned: characteristics, cabin class, availability, and pricing. It also notes the seatmap rendering. However, it does not explicitly differentiate this from closely related sibling tools like fs_get_seatmap or fs_get_seat_reviews.

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. Given siblings such as fs_get_seatmap, fs_get_seat_reviews, and fs_find_best_seats, the description does not state any selection criteria, exclusions, or preferred use cases.

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's 'Get the seat map' and cached, read-only framing directly contradicts the annotation destructiveHint=true, which signals destructive side effects. It also does nothing to reconcile that conflict; an agent cannot tell whether this read-like tool may mutate state.

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 filler; the purpose is front-loaded and the most important qualifier (cached data) is placed before the alternative. The only slightly redundant phrase is 'from our database,' but it does not hurt clarity.

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

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

The description covers output format and staleness, and the input schema is complete, but the destructiveHint=true annotation leaves a serious behavioral ambiguity unresolved. It also refers to 'search_flight' rather than the actual sibling fs_search_flight, so the completeness of routing is imperfect.

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 simple parameters (flight_number, flight_date), so the structured data already documents them. The description adds no extra meaning about parameter formatting or default behavior, which is acceptable but not an enhancement.

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 (seat map for a flight) and a clear retrieval verb, and it spells out what is shown (all seats, cabin classes, characteristics, availability) and the output forms (text + interactive visual). It does not explicitly contrast with close siblings like fs_get_seat_info or fs_find_best_seats, so it falls just 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?

It explicitly states when to prefer the fresh-data alternative: 'Returns cached data — for fresh/updated data, use search_flight (sign in via OAuth).' This gives an agent a clear condition for choosing another tool. However, the sibling is actually named fs_search_flight, so the pointer is slightly ambiguous.

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 describes a read-only 'Get' operation and mentions 'no auth required', but the annotations include destructiveHint=true, which implies potential destructive side effects. This directly contradicts the description's clear read-only nature, so the score is 1 due to the annotation contradiction.

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 compact sentences front-load the core purpose and then add useful return-field details and the no-auth note. Every sentence earns its place without redundancy.

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

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

For a simple 2-parameter read-only tool, the description covers purpose, optional filtering, returned fields, and auth requirements. It lacks pagination or result-limit details, but those are minor given the tool's simplicity; the destructive annotation contradiction reduces completeness confidence.

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 flight_number and seat_number. The description adds that filtering by seat is optional, but otherwise does not need to compensate for parameter documentation gaps.

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: 'Get user-submitted reviews for a flight', and clarifies optional filtering by seat. It also lists what the response contains, making it distinguishable from sibling tools like fs_get_seat_info and fs_get_seatmap.

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 clearly conveys when to use the tool: when an agent needs user-submitted reviews for a flight, optionally for a specific seat. It provides clear context but does not explicitly mention alternatives or exclusion conditions.

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

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

Annotations already include readOnlyHint=true and destructiveHint=true, which is contradictory. The description adds that it 'renders an interactive seatmap,' implying a UI display but not discussing any side effects or the nature of the interactivity. It does not clarify the conflicting destructive hint, so behavioral transparency is only partially addressed.

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

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

Two concise sentences, front-loaded with the core function and immediately followed by the usage context. No wasted words, and the key differentiator is present.

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 output schema, the description is largely complete: it explains the recommendation and rendering behavior, and when to use it. It could specifiy what 'interactive' entails (e.g., does the user select a seat?) or how it differs from fs_find_best_seats, but the low complexity keeps the 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 both flight_number and flight_date having meaningful descriptions. The tool description itself adds no parameter-level detail, so it relies on the schema. Per rubric, baseline 3 is appropriate.

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

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

The description states a specific verb and resource: it 'recommends the best seats on a flight and renders an interactive seatmap.' It also distinguishes itself from siblings by positioning as the 'good default' when no seat preferences are specified, which separates it from fs_find_best_seats and fs_get_seatmap.

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 gives a usage context: 'Good default when the user wants help finding a seat but hasn't specified preferences.' This clearly indicates when to use the tool, but it does not name alternative seat tools or provide exclusions, so it stops short of a full 5.

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 destructiveHint=true while the description describes a non-destructive list operation. Even though readOnlyHint=true aligns with listing, the destructive hint directly contradicts the description's implied no-side-effect behavior, so the behavioral profile is inconsistent.

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, each earns its place: one states scope and result content, the other flags authentication. The core action is front-loaded with no wasted words.

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

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

For a simple zero-parameter listing tool, the description covers purpose, output fields, and authentication. However, the contradictory destructiveHint annotation leaves the behavioral context ambiguous, so the overall definition is not fully coherent.

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?

There are no parameters; the schema is an empty object with 100% coverage. The baseline for zero-parameter tools is 4, and the description correctly does not invent parameter details.

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

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

The description uses a specific verb ('List'), names the resource ('seat alerts'), and clarifies scope ('all your seat alerts (active and inactive)'). This clearly distinguishes it from sibling tools like fs_create_seat_alert and fs_delete_seat_alert.

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 establishes a clear use case—listing all current and historical alerts—and notes an authentication prerequisite. It does not explicitly exclude alternatives, but for a zero-parameter list tool, the context is sufficient.

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?

Adds account/OAuth requirement, paid-tier behavior, and credit consumption beyond annotations; the credit side effect also helps explain idempotentHint=false. It does not elaborate on the destructiveHint=true signal, but the described operation is a search with a quota 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?

Three tight sentences front-load the purpose, then prerequisites, side effect, and return type — no filler or restatement of the name.

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?

Covers purpose, auth, plan gating, credit cost, and return type, while the schema covers parameters. Missing explicit guidance on sibling selection or fallback behavior, but not required for safe invocation.

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

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

The schema already documents both parameters with format and example (100% coverage), so the description adds no parameter-level detail. Baseline 3 is appropriate.

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

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

States a specific verb ('Search') and resource ('flight'), and differentiates by targeting 'fresh seatmap data' and noting 'new flights not yet in our database' — distinguishing it from database-lookup siblings like fs_get_seatmap or lookup_flight.

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 explicit context: requires a signed-in account via OAuth, paid plan users can fetch not-yet-database flights, and it uses a search credit. It does not explicitly name sibling alternatives or state when to prefer fs_get_seatmap, so no 5.

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 helpful context (editorial Q&A with citable content, no account needed), and readOnlyHint already signals safety. However, the annotations also carry destructiveHint:true, which is inconsistent with the read-only get semantics, and the description provides no explicit statement of absence of side effects to resolve that ambiguity.

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

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

The description is compact but complete: it covers purpose, use case, parameter format, output nature, and access requirements with no filler. The most identifying information is front-loaded in the first sentence.

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 lookup tool with no output schema, the description is nearly complete: it gives programme examples, input format, output format, and auth status. It stops short of specifying response shape or handling for unknown programmes, though those are minor for editorial FAQ content.

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 schema already defines 'program' as a slug or loose name with examples. The description repeats this in prose but adds no new semantic details such as normalization, case-sensitivity, or the full list of supported programmes.

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 ('Get') and resource ('curated award-chart FAQs, sweet spots, and booking tips') scoped to a loyalty programme. This clearly separates it from raw chart tools like get_program_partner_chart and from more general knowledge-base searches.

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 explicitly says to use it to answer questions about award pricing, best redemptions, and how to book. It does not name sibling alternatives as exclusions, so an agent still has to infer when to prefer get_program_partner_chart or recommend_redemption.

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 says 'Look up,' implying a purely read-only operation, but the annotations include destructiveHint: true. This is a direct contradiction: the description conveys safety while the annotation flags potentially destructive behavior. Even though readOnlyHint is also true, the conflicting annotations and description create serious ambiguity for an agent.

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 filler. The core action is front-loaded, and the second sentence provides actionable guidance. 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 read tool, the description conveys the purpose, the output concept (days from departure), and a concrete use case. It could be more explicit about the exact return shape, but the description is sufficient for an agent to invoke it correctly.

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

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

Schema coverage is 100%, with the only parameter 'airline' already documented with an IATA code example. The description adds no additional parameter semantics beyond implying the airline is central to the lookup, so a baseline 3 is appropriate.

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

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

The description uses a specific verb and resource: 'Look up when an airline opens award seats for booking (days from departure).' It is clear about what the tool does, but it does not differentiate itself from the sibling tool list_award_release_windows, which could be easily confused with this one.

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 explicit usage context: 'Use this before searching for a date >330 days out to warn the user if inventory hasn't been loaded yet.' It does not state when not to use it or name alternative tools, but the intended workflow is clear enough.

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 says 'Get flight-level detail', which is read-only in meaning and consistent with readOnlyHint=true. However, destructiveHint=true directly contradicts the described behavior, creating serious ambiguity about whether calling this tool can have side effects. Per the rubric, a description that contradicts annotations must receive a 1.

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

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

Two dense sentences with no filler. The first sentence front-loads purpose and output contents, and the second gives the single input and prerequisite. 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?

Given one required parameter, no output schema, and no nested objects, the description covers everything needed: input source, prerequisite, and a concrete list of returned flight-level fields. The only issue is the annotation contradiction, which is captured separately.

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

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

The schema already describes trip_id as 'The trip_id field from an award search result row' with 100% coverage. The description adds the brand 'seats.aero' and reinforces the provenance, but does not add substantial new meaning beyond the schema.

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

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

The description uses a specific verb and resource: 'Get flight-level detail for one award result', then enumerates the exact contents (flight numbers, aircraft, times, stops, booking links). It also names the upstream tools search_all_airlines and search_availability, which clearly separates it from the many sibling search/get 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 description clearly indicates when to call the tool: after an award search, for a single award result, using the trip_id from a seats.aero result row. It also states the prerequisite of a connected seats.aero account. It does not explicitly list exclusions or alternatives, but the usage context is unambiguous.

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 and openWorldHint. The description adds valuable behavior: it returns tiered base pricing and bonus promotions, handles the no-program case by returning all programs, and states 'Free — no account needed,' which discloses authentication requirements. It doesn't contradict the annotations, despite the annotation's internal conflict (destructiveHint true), which is not the description's responsibility.

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 four short sentences, each earning its place: purpose, output, usage trigger, and an optionality note plus authentication. It is front-loaded with the core function and wastes no words.

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

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

For a simple read-only tool with two optional parameters and no output schema, the description covers the core semantics: what it does, when to use it, how parameters behave, and the lack of auth requirement. It doesn't detail the exact response shape, but the statement about 'tiered base purchase pricing and any active bonus promotion' gives a reasonable expectation. Overall, an agent can call it correctly.

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

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

Schema coverage is 100% for both parameters (program and quantity). The description adds meaningful context for 'program' by explaining the omitted-program behavior ('returns all programs with pricing data'), which goes beyond the schema's bare definition. It doesn't specify quantity syntax, but that is already in the schema.

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

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

The description states a specific verb ('Get') and resource ('cost to buy points/miles for a loyalty program'), and clarifies the output ('tiered base purchase pricing and any active bonus promotion'). It also gives a concrete sample question ('how much does it cost to buy X Avios/miles/points?') that makes the tool's distinct purpose unmistakable, even among context-heavy pricing siblings like get_pricing or get_points_valuation.

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 an explicit trigger: 'Use to answer how much does it cost to buy X Avios/miles/points?' It also explains the behavioral branch (with or without a program). However, it does not name alternatives or state when not to use it, though the specific use case effectively differentiates it 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 portrays a read-only lookup: 'Get', 'Returns', and 'Free — no account needed'. However, annotations include destructiveHint=true, which directly conflicts with that read-only framing. Even though readOnlyHint=true is also present, the contradiction makes the behavioral profile untrustworthy and warrants a score of 1.

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 four sentences and front-loaded with the core purpose, followed by return contents, input flexibility, a caveat, and access requirements. It earns its length, though the airline examples appear in both the description and the schema, creating slight 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 one-parameter lookup with no output schema, the description adequately explains return values (headline fee, exemptions, source link) and flags the partner-programme exclusion. Missing details like currency or response format are minor for this low-complexity 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?

The only parameter, 'airline', is already fully described in the schema with examples, so the baseline is 3. The description adds 'slug or loose airline name', which provides mild flexibility, but it largely duplicates the schema's 'Airline slug or name' wording. No significant new parameter meaning is added.

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 — the award-ticket cancellation/redeposit fee — and clarifies it applies to an airline's OWN loyalty programme. This immediately distinguishes it from sibling tools like get_partner_award_options and get_award_chart_faq. The verb 'Get' plus the stated return content makes the purpose unambiguous.

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

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

The description explicitly states when to use it (airline's direct loyalty programme) and gives a clear when-not condition: partner-programme fees differ. It does not name a specific alternative tool, but the boundary is strong 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?

The annotations carry readOnlyHint=true but also destructiveHint=true; the description frames the operation purely as a lookup and return, with no mention of any destructive side effect. This directly contradicts the destructiveHint annotation, and the description does not otherwise disclose rate limits, auth needs, or side-effect 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?

Three short sentences that front-load the action and outcome, then add a use case and cost note. No filler or redundant restatement of parameter schemas.

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 lookup with an output table, the description is mostly sufficient, but the destructiveHint contradiction leaves an unresolved behavioral question, and with no output schema the return shape is only vaguely described ('% of distance earned per booking class'). The 'Free' note also lacks context (free in credits? free of charge?).

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

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

Schema coverage is 100%, so the schema already documents all three parameters with formats and optionality. The description adds only a light restatement of 'per booking class,' which maps to fare_class but adds no new meaning over 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 verb ('look up'), resource ('mileage earning rates'), and scope ('for crediting a partner-airline ticket to a loyalty program'), and states the concrete output ('% of distance earned per booking class'). This clearly separates it from award-chart or flight-search 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?

Explicitly tells the agent when to reach for this tool ('Use when deciding which program to credit a flight to'), which is actionable context. It stops short of naming alternatives or exclusion conditions (e.g., when to use calculate_flight_earnings instead), so not a 5.

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 says 'Get details,' which implies a read-only operation and aligns with readOnlyHint=true, but the annotation destructiveHint=true directly contradicts that. This gives an agent conflicting safety signals, and the description provides no clarifying 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 efficient sentence with no filler. It front-loads the verb and resource, though it is so brief that it leaves important behavioral gaps.

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

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

With no output schema and no statement about return shape, error behavior, or booking types, an agent cannot fully predict the tool's response. The contradictory destructiveHint annotation further undermines completeness.

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

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

The schema has no description for booking_id, so coverage is 0%. The description only implies that booking_id identifies the booking, but does not explain expected format, scope, or how redemptions differ from paid bookings.

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

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

States a specific verb and resource: 'Get details of a specific flight booking/redemption.' This clearly distinguishes it from list/update/delete siblings by emphasizing a single booking, though it does not name those alternatives.

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

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

No guidance on when to use this tool versus alternatives like list_flight_bookings or get_award_trip_details. The usage context is only implied by the word 'specific' rather than explicitly 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 declare both readOnlyHint=true and destructiveHint=true, while the description presents the operation as a simple read-only 'Get.' This is a direct contradiction: a read-only availability lookup should not be destructive or non-idempotent, and the description discloses none of the conflicting side-effect risk.

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 compact and front-loaded: the first sentence states what the tool does, the second gives essential sequencing context, and 'Paid feature' is a meaningful warning. No words are 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?

With no output schema, the description should clarify what the response contains, but it only vaguely implies points availability and rate_plan without specifying returned fields. The contradictory destructive annotation also leaves behavioral side effects unexplained, making the tool incomplete for safe invocation.

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

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

Schema description coverage is only 33%, with only hotel_code having a descriptive comment. The description adds little beyond the word 'specific dates' and does not compensate for the undocumented check_in_date and check_out_date parameters or clarify how they should be formatted beyond the schema patterns.

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

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

The description clearly states a specific verb and resource: 'Get current points availability for a hotel on specific dates.' It also distinguishes itself from monitor_hotel_price by explicitly positioning this tool as a prerequisite step, so an agent can tell it apart from closely related 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?

'Use BEFORE monitor_hotel_price to find the correct rate_plan and current points rate' provides explicit sequencing and a concrete purpose. However, it does not mention when not to use this tool or name alternatives beyond monitor_hotel_price, so it stops short of full exclusion 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?

The description says 'Get details and full price history', which is a read-only retrieval, and readOnlyHint is true. However, destructiveHint is also true and idempotentHint is false, directly contradicting the described behavior. This is an annotation contradiction and seriously undermines an agent's ability to predict 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?

A single, front-loaded sentence with no filler. It immediately states the action and the distinguishing output, making the core purpose clear without unnecessary 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?

For a one-parameter getter, the description covers the essential context: which resource is targeted and what information is returned. No output schema exists, but 'details and full price history' gives a reasonable sense of the response. The only significant gap is that the contradictory destructive annotation is not addressed, though that is more a behavioral transparency issue.

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

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

Schema description coverage is 0%, so the description must compensate. It does clarify that the booking_id refers to a monitored hotel booking, but it adds no further detail about where the ID comes from, what range is valid, or how to interpret the returned price history. The single parameter is minimally documented beyond its name and type.

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

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

The description names a specific verb ('Get'), a specific resource ('monitored hotel booking'), and a distinct output aspect ('full price history'). This distinguishes it from siblings like list_hotel_bookings, get_hotel_availability, and get_flight_booking.

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 'monitored hotel booking' implies this tool is for bookings that are being price-monitored, and it is clearly not for flight bookings. However, it does not explicitly state when to prefer this over list_hotel_bookings or how to obtain a valid booking_id, so usage guidance remains implicit rather than explicit.

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

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

The annotation destructiveHint: true directly conflicts with readOnlyHint: true and with the description's purely informational framing ('list', 'Use this to answer', 'Free — no account needed'). The description gives useful data caveats, such as off-peak/saver estimates from published award charts, but it does not resolve the contradictory destructive annotation. This is an annotation contradiction.

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 compact and well ordered: purpose, example, intended user question, data caveat, and access constraint. No sentence is wasted, and the main function is front-loaded before the illustrative example and usage note.

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

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

For a tool with no output schema, the description states what will be returned: a list of loyalty programmes and point costs per cabin. It also discloses the estimate nature of the points and that no account is needed. It does not specify the exact result shape or empty-result behavior, but the task is simple enough that the description is largely 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 each parameter already has IATA format details and examples. The description's KE/ICN/LAX example reinforces the carrier and route semantics, but it adds no substantive parameter-level meaning beyond what the schema and examples already provide.

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

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

The description names a specific verb and resource: 'list which loyalty programmes can book that airline as a PARTNER and how many points it costs per cabin.' The Korean Air ICN→LAX example makes both inputs and expected output concrete. It is clearly distinguishable from sibling lookup tools like get_program_partner_chart by emphasizing partner bookings for a specific operating airline and route.

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 an explicit takeaway use case: 'Use this to answer "which of my programmes can book this flight and what's the cheapest?"' This is clear context for when the tool is appropriate. It does not explicitly name alternatives or state when not to use it, so it stops short of a 5.

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 presents a pure read operation ('Get', 'Returns') and even says 'Free — no account needed', but the annotations include destructiveHint=true and idempotentHint=false, which directly contradict a safe read-only lookup. While readOnlyHint=true is also present, the destructive hint is not reconciled by the description, creating a serious safety contradiction.

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 purpose, the return contents, and the input/auth requirements. It is front-loaded and free of filler.

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

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

For a one-parameter unauthenticated lookup with no output schema, the description covers the input, the output shape, and the access constraints. An agent has enough to call the tool correctly and interpret the result.

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

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

The schema already documents the single currency parameter at 100% coverage. The description adds real value by clarifying that a slug or loose name is acceptable and supplying concrete examples like 'chase-ultimate-rewards', 'amex points', and 'hyatt'. This goes beyond the schema's 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 names a specific verb and resource: 'Get the cents-per-point valuation' for a 'credit-card points/miles currency or hotel program'. It answers a concrete user question and is clearly distinct from sibling get_* tools like get_pricing or get_earning_rates.

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 — whenever a points/miles valuation is needed — and even explains the input forms ('slug' or 'loose name'). However, it does not explicitly contrast this tool with alternatives such as get_pricing, get_earning_rates, or get_program_rates, so an agent must infer the boundary.

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 presents this as a read-only summary ('Get a complete summary'), which aligns with readOnlyHint=true but directly contradicts destructiveHint=true. The description adds useful snapshot and refresh context but never acknowledges or reconciles the destructive annotation, making the tool's safety profile ambiguous.

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 tightly written sentences: the first states what the tool does and its contents, the second explains the snapshot relationship and when to call it. 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 zero-parameter tool, the description covers the data contents and the refresh trigger well. However, the contradictory destructiveHint remains unresolved, and there is no output schema or mention of return shape, so an agent still has an important behavioral unknown.

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, so the schema already provides complete parameter information; the baseline of 4 applies. The description adds no parameter-level detail, but none is needed.

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 ('Get a complete summary of your travel rewards portfolio') and enumerates the contents: points balances, spend, trips, destinations, and trends. This clearly distinguishes it from the many list_* and get_* 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?

Explicitly states when to call: after the user adds bookings or balances in-session when a refresh is needed, and reveals that it uses the same snapshot as the server-loaded preamble. It does not explicitly contrast itself with alternative list/get siblings or state when not to use it.

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

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

Annotation Contradiction: destructiveHint=true conflicts with the read-only 'Get the award pricing chart' semantics, while readOnlyHint=true marks it as read-only. The description adds 'Paid feature' and 'No date needed,' but the contradictory annotations make the tool's behavioral profile unreliable.

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 concise and front-loaded, using four short sentences that each add value: purpose, output content, no-date caveat, and paid-feature warning. There is no filler or redundant repetition.

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

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

For a simple 3-parameter lookup, the description covers the purpose and basic return content, and the schema covers constraints. However, the 'Paid feature' warning lacks billing/auth implications, and with no output schema, the exact return format is only generally 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?

With 0% schema coverage, the description partially compensates: 'specific airline route' implies departure_code and arrival_code, and 'No date needed' clarifies that no date parameter exists. However, it does not explain IATA code format or the supported airline list beyond what the schema's enum and patterns already provide.

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: get the award pricing chart for a specific airline route, and it clarifies what the result contains (points per cabin class, off-peak/peak). This clearly differentiates it from siblings like date-based award release windows or point-purchase pricing 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 description provides useful context—route-specific, no date needed, paid feature—but it does not explicitly say when to use this tool over similar siblings such as get_partner_award_options or get_program_partner_chart. The usage guidance is implied rather than explicitly 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?

Annotation Contradiction: annotations declare destructiveHint=true, while the description is clearly read-only ('Get ... award chart', 'Free — no account needed'). This is a serious inconsistency that undermines an agent's trust in choosing and invoking the tool. Even though the description adds useful caveats about trip_basis and confidence fields, the contradiction forces the lowest score.

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

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

Four dense sentences front-load the core resource and then provide essential caveats. Minor redundancy exists because the supported programme list echoes the enum, but the airline-name clarifications justify keeping it. No filler words or vague promises.

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 tool with no output schema, the description is unusually complete: it explains output form, how to match rows, which returned fields to read, one-way vs round-trip semantics, partner-only applicability, and the free/no-account condition. Nothing essential is missing for a correct call.

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

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

The only parameter is fully covered by the schema's enum and description, so the baseline is 3. The description adds value by mapping slugs to airline names (aeroplan=Air Canada), marking cathay-asia-miles as distance-based, and noting ANA's round-trip behavior. This goes beyond simple repetition of 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?

Description names a specific resource ('PARTNER airline award chart'), defines its form (region-pair or distance-band table), and delimits scope to partner-operated flights. It is clearly distinguishable from sibling tools by describing the output as a table with sources, confidence, and caveats.

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 warns that these charts apply to PARTNER-operated flights and not to a programme's own dynamically-priced flights, giving an agent a clear boundary. It does not name alternative sibling tools or state positive 'use this instead of X' conditions, so it stops short of full 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?

The description adds 'Free — no account needed', which is useful behavioral information beyond the annotations. However, it does not address the contradictory annotations (readOnlyHint=true but destructiveHint=true), leaving ambiguity about potential side effects. With annotations present, the bar is lower but the description still doesn't clarify this inconsistency.

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 purpose, then the return details, and finally a note about cost/account. It is concise with no wasted words and maintains clear structure.

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 parameter, the description is fairly complete: it states the full chart scope, all destinations, and free access. However, it doesn't mention potential limits like pagination or large responses, and it doesn't clarify the conflicting annotations or differentiate from similar siblings, leaving some gaps.

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

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

The schema has 100% coverage of the single parameter (program), and the description adds no extra information beyond saying 'specific loyalty program', which is redundant. Baseline 3 is appropriate where the schema already 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 verb 'Get' and resource 'award chart rates for a specific loyalty program', and clearly describes what it returns: all destinations with points per cabin class including off-peak/peak pricing. It is distinct from siblings like get_earning_rates and get_pricing, though it doesn't explicitly name 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?

No guidance is provided on when to use this tool versus alternatives. It describes what it does but doesn't explain the context or situations that would select it over the many similar award-related tools among 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 presents a read-only fetch operation, but the annotations declare destructiveHint: true and idempotentHint: false. This directly contradicts the described behavior of simply retrieving markdown content, creating serious ambiguity about 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.