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

Annotations already mark the tool as read-only. The description adds useful behavioral detail beyond that: it returns only a count, deliberately does not return flight payloads, and uses a specific query grammar. It does not cover rate limits or freshness, but that is not critical for a simple count tool.

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

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

Four short sentences carry purpose, return shape, syntax constraints, and an example. There is no filler or repetition; every sentence contributes to correct invocation.

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 one required parameter, no output schema, and simple count semantics, the description is complete: it explains the return shape, the query syntax, and gives an example. Nothing essential is missing for an agent to decide when and how to call 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 baseline is 3. The description adds a more detailed query example and explicitly warns against advanced syntax, but it largely restates the query parameter's schema text. The view parameter is left entirely to the schema, which already documents it fully.

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 ('Count flights matching a query') and clearly distinguishes itself from search tools by stating it does not return flights. It also narrows its syntax to the simplified form and names the advanced alternative it is not.

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

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

The description makes the count-only use case explicit ('without returning the flights themselves') and gives strong syntax guidance, including that fa_search_flights_advanced's grammar should not be used. It does not explicitly say 'use this when you only need a count and not flight data,' but the phrasing makes that 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?

Annotations indicate a non-read-only, mutable operation. The description adds critical behavioral details: the dry-run preview when confirm is false, the actual creation when true, and the tier restriction. This goes beyond the schema and annotations, though it doesn't describe rate limits or error states, which would be nice.

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 long, with the main action stated first. Every word adds value: the verb, the resource, the confirm behavior, and the tier requirement. No fluff, perfectly 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 tool with 15 parameters and no output schema, the description covers the core workflow and a critical authorization note. However, it does not describe the preview format or what the API returns on successful creation. It also lacks details on default behaviors (e.g., what happens if no filters are set). Adequate but could be more complete given the complexity.

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

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

Schema coverage is 100%, so the schema already describes all 15 parameters. The description adds value only for the confirm parameter by explaining the dry-run behavior. For other parameters, the description adds no extra meaning beyond the schema descriptions. Hence 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 states the exact action: 'Create a flight alert on your AeroAPI account.' It clearly differentiates from sibling tools like fa_update_alert and fa_delete_alert by focusing on creation. Additionally, it explains the dry-run mode, making the tool's core function unmistakable.

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

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

The description explicitly explains the confirm parameter's role (dry-run vs. actual creation) and warns about the required AeroAPI tier. It provides clear context on when to use each mode. Though it doesn't mention alternatives (e.g., updating versus creating), the sibling list makes that implicit, so the guidance is strong but not perfect.

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

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

Beyond annotations (idempotent, non-read-only), the description discloses the dry-run behavior (no network call without confirm:true) and tier requirement, providing critical behavioral context that annotations alone do not cover.

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, front-loaded with the core purpose. Every sentence contributes essential information without redundancy or fluff.

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 tool's core functionality, dry-run mode, and tier requirements. Without an output schema, it could detail what the preview returns, but overall it is sufficiently complete for a delete operation with conditional behavior.

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 reinforces confirm behavior but adds little new meaning beyond what the schema already provides, meeting the baseline for high 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 clearly states 'Delete a flight alert by id,' specifying the verb (delete) and resource (flight alert by id). Among siblings, there are create, update, get, and list alerts, making this tool's delete function distinct and unambiguous.

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

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

The description explains the confirm parameter's role in triggering a dry-run vs actual deletion, and specifies the required AeroAPI tier (Standard or Premium) with a 401 error for free tier. It gives clear context for using the tool but does not explicitly compare to siblings like fa_create_alert or fa_update_alert.

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

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

Annotations declare readOnlyHint and openWorldHint, and the description adds valuable behavioral context beyond that: the tool uses a Boolean query language, returns predicted data, and crucially warns about premium-tier billing and anticipated 402/403 failures. This is meaningful, non-obvious behavioral disclosure, with no contradiction to 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 filler. The primary purpose is front-loaded, the key distinction from a sibling is included, and the critical premium-tier caveat is placed prominently. Every word earns its place.

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

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

The description, combined with rich schema annotations for view/cursor/max_pages and no output schema, is largely sufficient for a caller to select and invoke the tool correctly. It covers what the tool does, how it compares to a sibling, and the most likely error condition. A slightly fuller statement about the nature/shape of predicted data would round it out, but 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?

Schema description coverage is 100%, so the baseline is 3. The description adds extra semantics by explaining that the query parameter uses a Boolean query language and by pointing to fa_search_flights_advanced as a reference implementation, enriching the bare schema label 'Boolean query expression'.

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+resource: predictive flight search via AeroAPI Foresight. It differentiates itself from the closely related sibling fa_search_flights_advanced by explicitly noting 'like fa_search_flights_advanced, but predicted data', making the tool's scope instantly distinguishable.

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 clear context for when to use this tool: for predicted data rather than the standard flight search, and it names the analogous sibling for comparison. It also warns about premium-tier access and expected 402/403 errors, which guides usage expectations, though it stops short of explicitly listing exclusions 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 readOnlyHint and openWorldHint annotations already carry the main safety context, and the description's 'Get' is consistent with a read-only operation. The description adds the scope of the lookup ('by tail number') and the result domain ('registered owner'), but does not disclose error behavior, response shape, or data freshness.

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

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

A single sentence front-loads the operation and the lookup key, with a helpful concrete example ('N12345'). There is no filler or 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?

For a simple two-parameter, read-only lookup, the description, together with the fully described schema and read-only annotations, is largely complete. It does not describe the output shape, and there is no output schema, but the phrase 'registered owner' conveys the expected result domain sufficiently.

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

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

Schema description coverage is 100%, and the schema already documents both 'ident' and the compact/full 'view' behavior. The free-text description essentially repeats the ident example and adds no parameter semantics beyond what the schema provides.

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

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

The description names the exact operation ('Get the registered owner'), the resource ('an aircraft'), and the query key ('tail number / registration') with a concrete example. This is specific and clearly distinguishes it from sibling flight, airport, alert, and operator 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 implies the trigger condition: use it when you have a tail number/registration and need the registered owner. It does not explicitly contrast with alternatives, but no direct sibling tool has the same owner-lookup purpose, so exclusions are unnecessary.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the agent knows this is a safe read operation. The description adds the accepted code formats (ICAO/IATA/LID), which is useful. The view parameter description in the schema adds rich behavioral context about response shapes (compact vs full, what gets stripped). The description itself doesn't add much beyond the schema, but the schema's view description is part of the tool definition and provides strong behavioral transparency. Since the description doesn't contradict annotations and the schema carries the behavioral load, a 4 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?

One sentence, front-loaded with the verb and resource, and the parenthetical about code formats is efficient. Every word earns its place. The schema's view description is verbose but that's in the schema, not the description.

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 tool with 2 parameters, 100% schema coverage, and readOnlyHint=true, the description plus schema is nearly complete. The only minor gap is that the description doesn't mention what the response contains (e.g., airport name, location, timezone), but with no output schema and the openWorldHint, the agent can infer the response from the 'details' wording. A 4 is appropriate; a 5 would require explicit mention of return fields or when to prefer this over fa_resolve_airport.

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

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

Schema description coverage is 100%, so the schema already documents both parameters thoroughly. The description adds the accepted code formats (ICAO/IATA/LID) which reinforces the id parameter semantics. The view parameter has an exceptionally detailed schema description explaining the difference between compact and full, including what gets stripped. The description doesn't need to add more because the schema does the heavy lifting. Baseline 3, but the description's explicit mention of code formats adds a small increment.

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 details'), a specific resource ('airport'), and the exact identifier formats accepted (ICAO, IATA, LID). It clearly distinguishes this from sibling tools like fa_resolve_airport or fa_list_airports by focusing on fetching details for a single airport by code.

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

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

The description implies when to use this tool: when you have an airport code and need details for that specific airport. It doesn't explicitly name alternatives or exclusions, but the sibling list shows many other airport tools (e.g., fa_get_airport_flights, fa_get_airport_delays) and the description's focus on 'details for an airport by code' provides clear context. A small deduction for not explicitly saying 'use fa_resolve_airport if you need to resolve a code to an airport' or similar.

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 read-only and open-world behavior. The description adds that results are current and scopeable, but it does not mention response shape, empty results, or that the view parameter changes output verbosity.

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: action, resource, and the all-versus-single condition are front-loaded and unambiguous. No filler, and the most useful decision cue appears early.

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 delay lookup, the description plus annotations and schema cover all core usage. It could have named the view/pagination trade-off, but the id-scoping rule is the main behavioral branch and it is explicit.

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 id and view well. The description only re-states the id scoping behavior and adds no extra parameter context, which is acceptable because schema coverage is high.

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 current airport delays' — and immediately clarifies the two scoping modes: all delayed airports or one airport when id is provided. No sibling tool covers delays specifically, so the tool is easy to distinguish.

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 a clear decision rule: omit id for all delays, include id for a single airport. It does not name alternative tools, but the delay scope is unique among siblings and the condition 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, covering the safety profile and response extensibility. The description adds a useful behavioral detail by listing the four count categories and stating the data is 'current,' but it does not discuss data freshness, unavailable-airport behavior, or whether scheduled counts refer to the current day. This is adequate but not rich.

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

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

One tight sentence with no filler. The verb, scope, and response keys are front-loaded, and every word contributes to the agent's understanding.

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 complete parameter schema and readOnly/openWorld annotations, the description covers the operation and the expected response shape despite lacking an output schema. The main gap is explicit sibling differentiation, but that is already addressed in the usage dimension, so the description is otherwise sufficient.

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

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

Schema description coverage is 100%, with id and view both fully documented including pattern, enum, and semantics. The description does not need to explain parameters further, and it does not, 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 verb ('Get') and resource ('an airport'), and it enumerates the exact return categories (departed, enroute, scheduled_arrivals, scheduled_departures), so an agent can tell this is an aggregate-counts tool rather than a flight-list or map tool. It does not explicitly name sibling alternatives, 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?

There is no guidance on when to use this tool versus related siblings such as fa_get_airport_flights, fa_count_flights, or fa_get_airport_delays. The only usage signal is the tool name and generic 'at an airport,' leaving selection to inference.

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

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

The annotations already declare readOnlyHint=true and openWorldHint=true, so the agent knows this is a read-oriented, open-world operation. However, the description adds no behavioral context beyond that: it does not describe response shape, paging behavior, data freshness, or what the open-world annotation implies in practice.

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 names the resource and the key choice of board type. It contains no filler, repetition, or unnecessary detail, and every word contributes to understanding what the tool does.

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

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

The tool has 8 parameters and no output schema, and the description covers only the board selection dimension. The schema handles parameter documentation, and annotations handle side-effect safety, but the description leaves gaps around time-window semantics, paging, response contents, and how this relates to sibling airport tools.

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

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

Schema description coverage is 100%, so the parameters are already fully documented in the schema. The description's mention of arrivals/departures mirrors the board enum in the schema without adding meaning. The especially nuanced view parameter is explained only in the schema, not in the description.

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 a flight board for an airport." It further disambiguates the tool by enumerating the supported board variants (arrivals, departures, scheduled arrivals, scheduled departures), which distinguishes it from sibling airport tools like fa_get_airport_flight_counts and fa_get_airport_routes.

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

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

The description gives no guidance on when to use this tool versus alternatives such as fa_get_airport_flight_counts, fa_get_airport, or fa_search_flights. There are no excluded cases, no preferred context, and no mention of the sibling tools that would make the selection decision 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?

Annotations already declare readOnlyHint=true and openWorldHint=true. The description adds meaningful behavioral context by clarifying that the tool returns only the most popular routes and that those results include aircraft types, counts, and filed altitudes. It does not discuss pagination or cost behavior, but it is consistent with the read-only annotation and adds a useful output contract.

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

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

The description is a single, front-loaded sentence with no filler. It communicates the operation, the input relationship, and the output components in a compact way that is easy for an agent to parse.

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

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

For a read-only route-statistics tool with fully documented parameters and no output schema, the description provides sufficient context. It states what the tool returns and how the two key parameters relate, while the schema supplies the remaining details about cursors, paging bounds, and response shaping.

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

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

Schema description coverage is 100%, so the schema already documents all five parameters, including the view enum, cursor, max_pages, and airport code formats. The description adds no new parameter detail beyond restating origin/destination conceptually, 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 names a specific verb ('Get'), a specific resource ('most popular routes'), and the two inputs that define the operation ('origin and destination airport'). It also states the output payload (aircraft types, counts, filed altitudes), which distinguishes it from siblings like fa_get_flight_route or fa_get_airport_flights.

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

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

The description makes the intended use clear: obtain aggregated, popular route statistics between two airports. It does not explicitly name alternatives or exclusion criteria, but the 'between an origin and destination airport' phrasing provides enough contextual guidance to separate it from flight-specific or airport-specific tools.

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

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

Annotations indicate readOnly (safe) and openWorld (external data). The description adds context by mentioning report types but doesn't elaborate on external dependencies or rate limits. However, the parameter descriptions for 'view' and 'max_pages' disclose important behavior (admitting uncertainty about field projection, billing per page), which is notable and 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 concise with two clear clauses. It front-loads the primary purpose ('Get weather for an airport') and specifies the key options. It is appropriately sized, though slightly under-detailed on usage scenarios.

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

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

For a 5-parameter tool with no output schema, the description is fairly complete. It covers the core functionality and hints at response shapes (via 'view'), but lacks explicit mention of pagination (cursor) in the description, though schema covers it. Given the complexity, a brief note on pagination would improve completeness.

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

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

Schema coverage is 100%, with each parameter described in the schema (e.g., 'id' as airport code, 'report' with enum, 'view' with detailed explanation). The description itself adds minimal extra meaning, so the baseline of 3 is appropriate per the criteria.

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 verb ('Get') and resource ('airport weather') and specifies the two report types (METAR observations and TAF forecast). It distinguishes from sibling tools like fa_get_airport (airport info) and fa_get_airport_delays (delays), making its 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 implies usage for weather data via the 'report' parameter, but does not explicitly contrast with alternatives like fa_get_airport for non-weather info. A clear statement like 'Use this for weather only; use fa_get_airport for general airport details' would be stronger, but the purpose is evident 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?

Annotations already declare readOnlyHint and openWorldHint, and the description adds meaningful behavioral context beyond that: the auth-tier requirement and the 401 failure mode for free-tier callers. It does not contradict the annotations and provides useful operational guidance.

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

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

The description is two short sentences with no filler. The primary action is front-loaded, and the auth caveat is a necessary second sentence that 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 read-by-id operation with readOnlyHint and openWorldHint annotations, the description is largely complete: it identifies the resource, the key constraint, and the auth failure mode. It does not describe return fields or error cases beyond 401, but the absence of an output schema makes that a minor gap.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-level detail beyond the schema; 'by its id' simply restates the id parameter, and the view parameter is already richly explained 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 ('single configured flight alert'), and clarifies retrieval is by id. It clearly implies a contrast with list-style siblings, though it does not explicitly name fa_list_alerts or other alternatives.

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

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

The description gives useful context: it requires a Standard or Premium tier and notes the free Personal tier returns 401. However, it does not explicitly state when to prefer this tool over siblings like fa_list_alerts or fa_update_alert; usage is only implied by 'single ... by its id'.

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 readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds meaningful behavioral context beyond annotations by disclosing the tier requirement and the 401 failure for the free Personal tier, which helps an agent anticipate authentication outcomes.

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 states exactly what the tool returns and immediately calls out the auth requirement. Every clause 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 read-only getter with an optional parameter, the description covers the key behavior, the tier restriction, and the 401 outcome for unsupported plans. It doesn't describe the return shape, but the tool is simple enough and the schema documents the one parameter.

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 description itself adds no parameter-level meaning, but the schema fully documents the single optional `view` parameter with compact/full semantics and even explains why no field projection is provided. With 100% schema coverage, the baseline score of 3 applies.

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

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

The description uses a specific verb ('Get') and clearly identifies the resource: the current delivery/webhook endpoint for AeroAPI alerts. It distinguishes itself from sibling tools like fa_set_alerts_endpoint and fa_get_alert by naming the exact object being retrieved.

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 states the retrieval purpose and adds a usage constraint: the free Personal tier receives a 401. It does not explicitly name alternatives or exclusion conditions, but the getter/setter relationship with fa_set_alerts_endpoint is inferable from naming.

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 the tool read-only, and the description adds valuable behavioral context by disclosing the tier requirement and the 401 failure on the free tier. It does not cover rate limits or pagination behavior, but with readOnlyHint/openWorldHint the added tier warning is meaningful.

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-loads the core purpose, and places the tier caveat at the end without redundancy. Every sentence adds selection-relevant 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 description provides enough context for selection and invocation: purpose, scope relative to fa_get_flights, and tier requirement, while all seven parameters are fully described in the schema. With no output schema, a slightly more explicit return-shape note would make it fully complete, but the openWorldHint reduces that need.

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 carries the parameter documentation burden. The description repeats that ident can be a designator, registration, or fa_flight_id but adds no new per-parameter semantics 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 ('Get') and resource ('historical flights for an ident'), and explicitly contrasts with fa_get_flights by noting it covers the period beyond the recent window. This lets an agent distinguish it from the closely named sibling without inspecting schemas.

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

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

It states the exact condition for choosing this tool: historical data beyond the recent window covered by fa_get_flights. It also adds a prerequisite and failure mode (Standard/Premium tier; Personal tier returns 401), which is explicit usage guidance.

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

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

Annotations indicate readOnlyHint and openWorldHint. The description adds important behavioral context: writes PNG to disk with configurable directory, or returns inline base64. It does not contradict annotations since the write is client-side.

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 efficiently convey output, behavior, and default directory. Could be slightly more concise, but 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?

No output schema, but description explains return format (path or base64) and mentions PNG. It lacks error handling details but is adequate for a straightforward image retrieval tool with 6 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 covers all 6 parameters with descriptions. The description adds value by explaining the output type (PNG), return mechanism (path or base64), and default output directory logic, complementing 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 it retrieves a rendered map image (PNG) for a flight using fa_flight_id. This specific verb-resource combo distinguishes it from sibling tools like fa_get_flight_position or fa_get_flight_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 explains output modes (disk vs inline base64) but does not explicitly state when to use this tool over alternatives like fa_get_flight_track for raw data. Usage context is implied but not exclusionary.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the description carries a reduced burden. It adds the 'in-air' and 'most recent' constraints, which is useful behavioral context. However, it does not disclose behaviors like error handling for non-in-air flights or unknown IDs, and the openWorldHint isn't elaborated on in the text.

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

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

The description is a single, front-loaded sentence that immediately states the purpose without any filler. Every word carries meaning, and it is appropriately sized for a simple get operation.

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

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

For a simple lookup tool with no output schema and robust parameter documentation in the schema, the description is largely sufficient. It captures the core action and constraints. The only gap is the lack of explicit differentiation from similar siblings, but given the clarity of purpose, this does not significantly impair an agent's ability to 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 description coverage is 100%, with both parameters (id and view) documented in detail. The view parameter's description already explains the compact/full distinction and the lack of field projection. The tool description itself adds no additional parameter semantics beyond what the schema provides, so it meets the baseline but does not exceed it.

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

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

The description states a specific verb and resource: 'Get the most recent reported position for an in-air flight by fa_flight_id.' This clearly distinguishes it from similar siblings like fa_get_flight_track (full track), fa_get_flight_route (route), and fa_search_flight_positions (search), by focusing on the latest position for an in-air flight only.

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

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

The description implies when to use the tool (when you need the latest reported position of an in-air flight) but does not explicitly mention alternatives or exclusion criteria. It does not reference any sibling tools or say when not to use it, leaving the agent to infer based on naming and context.

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

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

Annotations already carry readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The 'decoded' qualifier adds a slight behavioral note that the raw route is decoded into fixes/waypoints, but the description does not disclose edge-case behavior such as what happens for an unknown fa_flight_id or a flight without a published route.

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 declarative sentence with zero filler: the verb is front-loaded, the resource is specific, and the key identifier appears at the end. Every word contributes meaning.

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

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

For a low-complexity read-only lookup with a rich schema (100% param coverage) and safety annotations, the package covers purpose, parameter semantics, and expected return shape ('fixes/waypoints'). The only real gap is sibling differentiation, which is a description-level omission rather than a failure of the overall context.

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's `view` description is unusually thorough (compact vs full, what compact strips, no field projection). The tool description only names 'fa_flight_id', which links the parameter to the purpose but adds no meaning beyond the schema, so the baseline 3 applies.

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

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

The description states a specific verb ('Get'), a specific resource ('decoded route'), and an access path ('by fa_flight_id'). The parenthetical '(fixes/waypoints)' clarifies the data type well enough to distinguish it from track/position/history siblings, though no sibling is explicitly named.

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 prefer this tool over the many flight-related siblings (fa_get_flight_track, fa_get_flight_position, fa_get_flight_history, fa_get_flight_map). No alternatives are named and no exclusions or prerequisites are stated; the agent must infer applicability solely from the word 'route'.

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

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

Annotations declare readOnlyHint=true and openWorldHint=true, so the agent knows this is a safe read operation. The description adds that it returns 'recent, current, and scheduled flights' for the ident, which is useful behavioral context. The view parameter description is notably transparent about the compact/full distinction and explicitly admits the server has no verified record of which fields matter, which is honest and helpful. However, it doesn't mention pagination behavior beyond the cursor/max_pages parameters, which are already in the schema.

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

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

The description is two sentences with zero waste. The first sentence states the core purpose and defines the key term (ident). The second sentence states the return scope. The view parameter description is longer but earns its place by explaining a non-obvious trade-off and admitting a limitation. Everything 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 read-only lookup tool with 100% schema coverage and no output schema, the description is quite complete. It defines the input (ident), the scope (recent/current/scheduled), and the view trade-off. The main gap is that it doesn't describe the return format or what fields the response contains, but with no output schema and the view parameter explicitly saying the server doesn't track which fields matter, this is a reasonable limitation. The openWorldHint annotation also signals that the response may contain unexpected fields.

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

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

Schema description coverage is 100%, so the schema already documents all 7 parameters. The description adds value by explaining what an 'ident' is (designator, registration, or fa_flight_id) and that the tool returns recent/current/scheduled flights. The view parameter description is exceptionally detailed, explaining the exact trade-off between compact and full. The description doesn't add much beyond the schema for start/end/cursor/max_pages, but the schema already covers those well.

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 flights') and resource ('for an ident'), and explicitly defines what an ident can be (designator, registration, or fa_flight_id). It distinguishes itself from sibling search tools by focusing on a single ident rather than a search query, and the ident_type parameter further disambiguates interpretation.

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 states when to use this tool: when you have an ident (designator, registration, or fa_flight_id) and want recent, current, and scheduled flights for it. It doesn't explicitly name alternatives like fa_search_flights for when you don't have an ident, but the ident-centric framing makes the usage context clear. The ident_type parameter also provides guidance on how to disambiguate the ident.

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

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

Annotations already declare readOnlyHint=true, and the description's 'Get' is consistent with that. The description adds the breadcrumb-log semantics, but does not disclose other behavioral traits such as default handling of estimated positions, response size, or data freshness. It is not a contradiction, but it adds only modest value beyond the annotations.

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

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

One sentence with no filler, front-loading the core action and resource. The parenthetical adds precision without bloating the text. 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 read-only lookup with one required parameter, the combination of a clear description, rich schema documentation, and readOnly/openWorld annotations is largely complete. The main gap is not specifying how this differs from fa_get_flight_position or when the 'view' default matters, but those are minor relative to the tool's simplicity.

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 even though the description itself gives no detail about 'view' or 'include_estimated_positions'. The schema's own descriptions are significantly more detailed than the tool description, and the description does not add parameter-level meaning.

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

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

The description uses a specific verb, resource, and key: 'Get the position track (breadcrumb log) for a specific flight by fa_flight_id.' The parenthetical 'breadcrumb log' helps distinguish it from a single current position. This is clear and unambiguous.

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

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

The description implies this is for a historical position trail, but it never explicitly tells an agent when to choose this over fa_get_flight_position, fa_get_flight_route, or fa_get_flight_map. No alternatives or exclusions are stated, so usage context must be inferred.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, covering the safety profile. The description adds no behavioral context beyond the annotations—it does not mention pagination, response shape, rate limits, or that results may be incomplete due to the openWorldHint. Since annotations already provide the core safety signal, the description misses the opportunity to add value (e.g., that results are paginated via cursor or capped by max_pages). This is a notable gap for a tool with 7 parameters.

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, unambiguous sentence without any filler. It front-loads the core purpose and includes the key constraint (statute miles). Every word earns its place, and there is no redundancy with the schema or annotations.

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 a tool that could return complex paginated results (cursor, max_pages, view), the description is too minimal. It does not mention the response shape (e.g., list of airport objects), pagination behavior, or anything about the optional parameters. An agent cannot infer that results are paged or that 'view' affects field richness without opening the schema. The description covers only the primary intent, leaving out critical context for correct invocation.

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

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

Schema description coverage is 100%, so every parameter already has a description (including radius, latitude, longitude, and the optional view/cursor/only_iap/max_pages). The tool description adds no meaning beyond the schema; it does not explain relationships between parameters, like that max_pages and cursor are used together. Per the calibration rule, with high coverage, a baseline of 3 is appropriate.

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

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

The description states a specific verb ('Find'), a resource ('airports'), and the key scoping criteria (near a latitude/longitude within a radius in statute miles). This clearly differentiates it from sibling tools like fa_get_airport (single lookup) or fa_list_airports (potentially broad list) by tying the search to a geographic proximity query.

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

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

The description implies when to use it (when a location-based search for airports is needed) but does not explicitly state alternatives or exclusion conditions. It does not mention that fa_list_airports or fa_search_flights are not the right choice, nor does it note preferences such as 'use this instead of fa_list_airports when you have coordinates'. This is adequate for a simple, obvious use case but lacks explicit routing guidance.

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

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

Annotations already provide readOnlyHint=true and openWorldHint=true, indicating the tool is read-only and may return unexpected fields. The description adds that it retrieves details by code, which is basic. It does not describe the response shape (other than the view parameter) or any specific behavior beyond that. Given annotations cover the read-only nature, the description adds minimal but acceptable context, so 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?

The description is one sentence, concise and front-loaded with the purpose. It is efficient, but it could be slightly more structured, perhaps mentioning the view parameter behavior, which is already in the schema. The conciseness is good, no wasted words, and it is easy to parse. It earns a 4 for being appropriately sized, though not as exemplary as a two-sentence summary with alternatives.

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

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

Given the tool has a read-only snippet from annotations, a clear schema, and no output schema, the description is adequate for a simple lookup. It states the input (code) and provides a hint about ICAO/IATA. It does not explain what details are returned (e.g., name, country, callsign) or any pagination or error cases, but for a read-only lookup tool, it is reasonably complete. However, it could list typical fields returned for agents to set expectations, so a 3 is fair.

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%, meaning both parameters (id and view) are described in the schema. The description reiterates that id is the operator code (ICAO/IATA), which is already in the schema's description. The view parameter is fully described in the schema, including the difference between compact and full. The description adds no new meaning beyond the schema, so 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 tool's purpose: 'Get details for an operator (airline) by code (ICAO like UAL, or IATA like UA).' The verb 'Get' and resource 'operator' are specificaine, and the code types are clarified. It is distinct from siblings like fa_list_operators, but does not explicitly name that alternative, so a minor deduction. The description does not confuse with flight-related tools, and 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 it (when you have an operator code) and what the code can be (ICAO/IATA). It does not explicitly state when NOT to use it or mention alternatives like fa_list_operators for browsing all operators, or fa_get_operator_flights for flights of an operator. The usage context is clear for a lookup, but there is no explicit guidance on choosing 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 adds no behavioral information beyond the annotations. It does not disclose pagination behavior, rate limits, data freshness, or any side effects. The readOnlyHint and openWorldHint annotations already cover the safety and dynamic nature, but the description contributes nothing additional to the agent's understanding of how the tool behaves.

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 that front-loads the primary purpose and lists board types. It contains no fluff or redundancy, making it easy for an agent to parse quickly.

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

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

The description covers the core purpose but is thin on context. It does not differentiate from similar siblings (e.g., fa_get_flights), nor does it mention the 'view' or pagination options, though these are documented in the schema. Given the tool's moderate complexity and the rich schema descriptions, the description is adequate but not comprehensive.

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 does not elaborate on any parameters. However, the input schema provides descriptions for all 5 parameters (100% coverage), including enums, defaults, and constraints (e.g., max_pages billing note). With full schema coverage, the baseline of 3 is appropriate; the description adds no extra parameter-level meaning.

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

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

The description clearly states the action ('Get a flight board'), the resource ('for an operator (airline)'), and enumerates the board types. This distinguishes it from airport-focused tools like fa_get_airport_flights, and the 'operator' qualifier makes its scope unambiguous. It is concise 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?

No guidance is provided on when to use this tool versus siblings such as fa_get_flights or fa_search_flights. The description states what it does but does not mention exclusions or alternatives. The agent must infer usage from the tool name and context, which is insufficient given the many similar flight-list tools.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, covering the read and open-world behavior. The description adds the 'airline-scheduled' scope and filter capabilities, but does not disclose further behavioral traits such as pagination or codeshare handling; those live in the schema. There is no contradiction with the annotations.

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

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

One sentence, front-loaded with the required date range and followed by the optional filters. There is no wasted wording, and the structure matches the tool's invocation pattern.

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 10-parameter tool, the schema richly covers required dates, filter patterns, pagination, and response view options, so the description does not need to repeat those. The only notable gap is the lack of guidance for selecting this tool over sibling flight-search tools, but the core invocation context is complete.

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

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

Schema description coverage is 100%, so every parameter already has meaningful documentation. The description adds marginal value by summarizing the main filters, but it does not provide any information beyond what the schema already contains.

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'), a specific resource ('airline-scheduled flights'), and the required date-range scope plus optional filters. It does not explicitly distinguish this from sibling flight-lookup tools, but the 'airline-scheduled' qualifier makes the resource clear enough for an agent to identify its core purpose.

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

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

The description implies usage: scheduled flight lookups over a date range, optionally narrowed by origin, destination, airline, or flight number. However, it gives no explicit when-to-use versus alternatives such as fa_get_flights, fa_search_flights, or fa_get_operator_flights, and it names no 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?

Beyond the readOnly/openWorld/idempotent annotations, the description adds concrete behavioral details: it makes exactly one authenticated request, never returns the credential itself, reports which credential source was used, and distinguishes three failure classes. No 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, front-loaded with the core behavior, and every sentence adds distinct value: mechanism, reported outputs, safety guarantee, and invocation trigger. No filler or repetition of structured fields.

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 diagnostic tool with no output schema, the description fully equips an agent: it explains the request, the response contents, safety implications, and the exact failure scenario it addresses. Nothing materially needed to call it correctly 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?

The input schema is empty with zero parameters, so there is no parameter burden for the description to carry. Per the rubric, the no-parameter baseline is 4; the description adds relevant context about credential resolution without needing parameter detail.

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 precise diagnostic action: resolve credentials the way real tools do, make one request to aeroapi.flightaware.com, and report the result. This clearly distinguishes it from the FlightAware data-retrieval and alert-management sibling 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?

It gives explicit when-to-use guidance: 'Call this when a real tool fails and you want to know which hop broke.' It does not name alternatives or state when not to use it, so it falls just 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 readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds the pagination behavior ('paged', 'Use the cursor to page through'), which is useful context beyond the annotations. It does not disclose other traits like rate limits, but the paging mechanism plus the annotations provide reasonable transparency.

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

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

Two short sentences with no filler. The primary action is front-loaded, and the paging instruction is direct. Every word earns its place, making this an exemplar of concise definition.

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

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

For a list endpoint without an output schema, the description is minimal but sufficient given the rich parameter schema and annotations. It does not explain return shape or edge cases, but the view parameter clarifies response fields. It may be slightly incomplete for an agent expecting output details, but the name and paging hint cover the essentials.

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 detailed parameter descriptions for view and max_pages. The tool description only restates the cursor usage ('Use the cursor to page through'), which is already in the schema. With high schema coverage, the description adds minimal value beyond the baseline, so 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 'List' and the resource 'airports known to AeroAPI', making the purpose unambiguous. It does not explicitly differentiate from sibling tools like fa_get_airport or fa_resolve_airport, but the action 'list' and the paging note set it apart enough for an agent to identify its role.

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

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

The description gives operational usage ('Use the cursor to page through') but does not state when to choose this tool over alternatives (e.g., when a complete list is needed vs. a single airport lookup). There is no explicit when-to-use or exclusion guidance, leaving selection partially to inference.

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

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

Annotations already mark the operation readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds valuable behavioral context beyond that: the account-scoped nature of the call and the tier requirement with its 401 consequence. There is no contradiction with the annotations.

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

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

The description is a single focused sentence that states the operation first and then adds the key prerequisite. There is no filler, and the most decision-relevant 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 read-only list operation with well-documented optional parameters and annotations covering safety, the description is largely complete. It does not explicitly describe the response shape or pagination flow, but the schema already documents cursor and max_pages, and no output schema is provided to summarize. The tier requirement is a valuable completion.

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

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

The input schema has 100% description coverage and already explains the view enum, opaque cursor semantics, and max_pages cap with cost rationale. The tool description adds no parameter-level detail, but none is needed because the schema carries the full burden.

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

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

The description names a specific verb and resource ('List the flight alerts configured on your AeroAPI account') and clearly targets the collection-list use case rather than create/update/delete or single-alert retrieval. It does not explicitly name a sibling to distinguish from, but the 'list' phrasing plus account scope is enough to separate it from fa_get_alert and fa_get_alerts_endpoint.

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 a clear eligibility constraint (Standard or Premium tier, free Personal tier returns 401), which is useful operational guidance. It does not explicitly say when to choose this tool over fa_get_alert or when to avoid it, so the when-to-use guidance is present only by implication rather than by explicit alternatives.

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

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

Annotations already declare readOnlyHint and openWorldHint, so an agent knows it is a safe read operation. The description adds the pagination behavior and the requirement to use a cursor, which are useful beyond the annotations. It does not detail rate limits, response shape, or how pages end, but the basic behavioral profile is covered.

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

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

The description is two short sentences with no filler. The purpose is front-loaded, and the pagination hint is placed at the end. The only minor redundancy is 'paged' followed by 'use the cursor to page through', but it does not hurt readability.

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

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

For a simple list endpoint with zero required parameters and 100% schema documentation, the description is acceptable: it names the entity, scope, and pagination. However, it offers no hint about output format or how pages terminate, and it does not distinguish from the singular 'get operator' tools. The lack of an output schema shifts some responsibility to the description, yet it remains thin.

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 all three parameters (view, cursor, max_pages). Each schema description already explains semantics clearly, including cursor's origin from responses.links.next. The description's 'Use the cursor to page through' slightly reinforces the cursor parameter but adds no new information beyond the schema.

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

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

The description clearly states a specific verb 'List' with the resource 'operators (airlines)' and narrows the scope with 'known to AeroAPI'. The 'paged' note adds a cardinal trait. It does not explicitly name a sibling tool, but the resource is unambiguous next to tools like fa_get_operator or fa_list_airports.

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

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

There is no guidance about when to choose this tool over siblings such as fa_get_operator or fa_search_flights. 'Use the cursor to page through' is an instruction for operating the pagination, not a when-to-use/alternative comparison. The purpose implies usage but the description never states a condition or exclusion.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, covering the safety profile. The description adds genuinely useful behavioral context beyond them: the canonicalization semantics and, critically, the auth failure mode ("the free Personal tier returns 401"). This is exactly the kind of failure information an agent needs up front. No contradiction with annotations.

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

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

Two tightly written sentences: the core purpose is front-loaded, and the critical tier/401 caveat follows immediately. Every word earns its place; zero filler.

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

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

Since there is no output schema, the description carries some burden for return values, and "canonical AeroAPI identifier (and equivalents)" plus the schema's detailed compact/full view semantics give the agent a workable picture of the response. Invocation requirements (id, optional id_type, tier prerequisite) are fully covered. A small gap: it never connects the resolved identifier to downstream airport tools, but nothing needed to call it correctly is missing.

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

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

Schema description coverage is 100%, including a notably thorough explanation of the view enum (compact vs. full and the explicit no-field-projection rationale). The description adds no new parameter semantics beyond restating the overall purpose, so the baseline 3 applies.

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

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

The description uses a specific verb ("Resolve") with a named resource ("airport code") and a precise outcome ("canonical AeroAPI identifier (and equivalents)"). This clearly distinguishes it from siblings like fa_get_airport (a lookup) and fa_resolve_flight (resolves flight codes), and an agent can tell its job from the first sentence.

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

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

The usage context is implied — an agent would reach for this when holding a raw airport code that needs canonicalizing — but no when-to-use/when-not-to-use guidance or alternative routing is given, despite ~30 siblings including closely related fa_get_airport and fa_resolve_flight. The tier note is a practical constraint rather than alternative-selection 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 readOnlyHint already communicates safety, and the description adds useful operational behavior: resolving to canonical form, returning alternate idents, and requiring a paid tier. That is sufficient disclosure for a simple lookup-style tool.

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

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

The description is concise and information-dense: a single clear sentence plus a necessary tier warning. 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?

Given a complete schema and read-only annotation, the description supplies the core semantics, output concept, and an important access constraint. It lacks only an explicit output shape or example, but that is not essential for this tool's simplicity.

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 parameters are already documented in the schema, including the ident_type enum and the default behavior. The description adds little parameter-level detail beyond naming the identifiers, so it does not materially improve on schema coverage.

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

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

The description clearly identifies the operation ('resolve'), the resource ('flight ident'), and the outcome ('canonical form and any alternate idents'). It is unambiguous and distinguishes this from airport or operator resolution 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 purpose and intended input are clear, and the tier restriction (Standard/Premium vs. free tier returning 401) is a useful selection cue. However, it does not explicitly contrast it with sibling tools 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?

While annotations already declare readOnlyHint=true and openWorldHint=true, the description adds behavioral context beyond the annotations: it states results are 'live' (implying temporal sensitivity) and describes the output nature ('returns position points rather than flight summaries'). This provides useful response-shape expectations without repeating structured attributes and does not contradict the annotations.

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

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

Three sentences: one states purpose and grammar, one clarifies the output type, and one gives a concrete example. Every sentence earns its place, no filler, and the key differentiator ('NOT the simplified '-keys' syntax') is strategically placed early.

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 four-parameter tool with no output schema, the description is nearly self-sufficient: it covers the query format, clarifies the difference from the advanced search tool, and describes the return semantics (position points). The schema already handles view/cursor/max_pages, and the description does not need to repeat those. It would be slightly improved by a note on output structure (e.g., list of point objects), but the missing piece is minor given annotations supply safety and currency signals.

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

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

Schema coverage is 100% so the baseline is 3, but the description adds real value by clarifying the query parameter's grammar and explicitly disassociating this tool from the simplified syntax, which is not in the schema. The example '{operator key values}' is repeated but the new 'NOT the simplified' cross-referencing helps the agent avoid a common mistake without opening any other definition.

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

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

The description clearly identifies the resource as 'live flight POSITIONS' with the specific verb 'Search', and immediately differentiates from the sibling tool by name: it returns 'position points rather than flight summaries'. This makes the tool's function and distinguishing purpose unmistakable, even without opening the schema.

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

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

It explicitly tells the model to use the structured '{operator key value}' query language and warns against the simplified '-key value' syntax, giving a concrete, actionable guidance for correct use. It references the sibling tool fa_search_flights_advanced by name and implies a choice based on output type (positions vs. summaries), though it stops short of an explicit conditional like 'when you need positions, use this; when you need summaries, use X'.

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, so the safety profile is covered without the description. The description adds the airborne scoping and the query-string behavior, but it does not disclose result shape, empty-result behavior, or request limits beyond what the schema already says.

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: it states the purpose first, then immediately gives the syntax, key list, and a worked example. Every sentence carries useful information, and there is no filler or repetition.

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

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

Given the schema already documents view, cursor, and max_pages, the description focuses correctly on the one underspecified parameter: the query string. It leaves some room for ambiguity around return format, but the core invocation requirements are sufficiently covered for a read-only search tool.

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

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

Schema coverage is 100%, so the baseline is 3, and the description goes further by enumerating all valid query keys, including the latlong value format, and providing a concrete example. It adds real meaning to the opaque 'query' parameter, though it does not explain the expected value format for every key.

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 ('Search airborne flights') and a concrete resource (AeroAPI flight search) with a clear syntax description. It distinguishes itself from the advanced sibling only implicitly through the phrase 'simplified query syntax', but it does not explicitly name or contrast any sibling tool.

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 choose this tool over fa_search_flights_advanced, fa_get_flights, or fa_search_flight_positions. The presence of many related sibling tools makes this omission meaningful; the agent must infer selection from the name and 'simplified' wording.

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 supply readOnlyHint and openWorldHint, so the description is not burdened with that baseline. It adds substantial behavioral detail about how the DSL is parsed: operator syntax, wildcard matching, units for altitude, and the meaning of the airline operator. It does not discuss error behavior or responses, but the DSL semantics are the crucial behavioral aspect here.

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 dense but every clause earns its place: the purpose statement, a worked example, the operator enumerations, and a list of common keys. It is front-loaded with the core distinction and the grammar list follows. No filler or repetition.

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

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

For a search tool the main challenge is the query language, and the description attacks that thoroughly. Pagination, view behavior, and max_pages are handled in the schema, so the description does not need to repeat them. It does omit error handling and a note about result shape, but given the annotations and the schema I consider this a good coverage without major 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 only describes query as a 'structured query string'. The description gives this parameter real meaning: it specifies the '{operator key value}' format, enumerates all operator types, includes a concrete example, and explains common keys and value units. This is a high-value addition to a parameter that would otherwise be opaque.

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 the exact resource (flights) and action (search), and explicitly positions itself against the sibling fa_search_flights ('more expressive than fa_search_flights'). This makes the tool's purpose unambiguous and distinct from its main alternative.

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

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

It names the semantic sibling fa_search_flights and calls itself more expressive, giving the agent good context for when this tool might be chosen over the simpler one. It does not provide an explicit 'use this when, else use that' rule, but the comparison is a strong usage signal.

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

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

Annotations already indicate readOnlyHint=false, idempotentHint=true, and openWorldHint=true. The description enriches this by detailing the dry-run vs. apply behavior, absence of network call without confirm, and auth restriction (401 on free tier). No contradictions with annotations.

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

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

Two sentences: the first front-loads the core action, the second adds critical behavioral details. No superfluous words. Perfectly 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 still mentions return behavior (dry-run preview). Auth requirement is covered. With idempotentHint and openWorldHint from annotations, the description provides sufficient context for an agent to use 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 coverage is 100%, so baseline is 3. The description adds value by explaining the url parameter's role (AeroAPI POSTs to it) and the confirm parameter's necessity for actual change. The format parameter's options are covered by the schema, but description adds context on delivery payload format. Marginal but useful 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 clearly states the tool sets the webhook endpoint for alert notifications, distinguishing it from siblings like fa_get_alerts_endpoint (retrieves) and fa_create_alert (creates alerts). The verb 'set' and resource 'delivery endpoint' are specific and unambiguous.

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

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

The description explicitly explains the dry-run behavior without confirm:true (returns preview, no network call) and the requirement of confirm:true to apply the change. It also notes the tier requirement (Standard/Premium, free Personal returns 401). This provides clear when-to-use and when-not-to-use guidance.

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

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

Annotations indicate readOnlyHint=false, idempotentHint=true, openWorldHint=true. The description adds transparency by explaining that the tool replaces the entire configuration, requires confirm to execute (otherwise dry-run), and requires a paid tier. No contradiction with annotations.

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

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

The description is two sentences with no wasted words. It front-loads the main purpose and then adds crucial usage details (confirm, tier). Every sentence provides necessary 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?

With 16 parameters (all described in schema) and no output schema, the description covers the essential behavioral context (dry-run, auth). It does not describe the return value, but given the schema richness, it 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?

The input schema has 100% description coverage for all 16 parameters. The description adds value by explaining the confirm parameter's role (dry-run vs. apply) and that the update replaces the configuration. This clarifies the semantics beyond the schema.

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

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

The description clearly states 'Update an existing flight alert (replaces its configuration).' The verb 'update' and resource 'flight alert' are specific. This distinguishes it from sibling tools like fa_create_alert and fa_delete_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 explains the dry-run behavior when confirm:true is absent and the actual update when present. It also mentions the required AeroAPI tier (Standard or Premium, not free Personal). It does not explicitly contrast with alternatives, but the context is clear.

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