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

With no annotations, the description carries the burden of behavioral disclosure. It discloses that the tool must be called before tasking orders and that its output must be presented to the user. It also establishes sequencing with quote_tasking_order. While it doesn't explicitly state read-only status, the tool's name and role imply a non-mutating analysis, and the mandatory-call behavior is a significant disclosure.

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

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

The description is two sentences, each earning its place. The first sentence delivers the core function and output summary; the second imposes the mandatory usage and precondition. There is 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?

The description covers the tool's role, output contents, and mandatory usage, which is sufficient for a 3-parameter tool. It lacks explicit read-only disclosure and error behavior, but the sibling context and the tool's name make the non-mutating nature clear. Overall, it gives a complete operational picture for an agent.

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

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

The schema already describes aoi and sensor_type, and the nested desired_date_range has property-level descriptions. The description adds no parameter-specific guidance beyond listing high-level analysis outputs. With moderate schema coverage (67%) and no compensating detail, the parameter semantics are adequate but not enriched.

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 function with a specific verb ('Analyze') and resource ('feasibility for a tasking order'), and enumerates the components (satellite availability, revisit window, cloud cover forecast, plain-language summary). This distinguishes it from sibling order-related tools like quote_tasking_order and execute_tasking_order.

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

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

The description provides explicit usage guidance: 'You MUST call this and present its output to the user before placing any tasking order' and identifies a specific precondition: 'call this before quote_tasking_order.' This clearly indicates when to use the tool relative to 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?

There are no annotations, so the description carries full behavioral disclosure burden. It mentions the monitor_id requirement but omits key behavioral details such as return values, idempotency, error handling, or what side effects (e.g., immediate verification request) might occur.

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

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

The description is two sentences, front-loaded with the action and purpose, and the prerequisite is valuable context. No redundant 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?

The description clearly states purpose and prerequisite, but for a creation operation with no output schema, it should also mention expected return (e.g., subscription ID) and potential error conditions. It is partially complete but missing these elements.

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 extra semantic beyond what the schema already states (e.g., monitor_id source is already in the schema).

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

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

The description clearly specifies the action ('Register') and resource ('webhook endpoint') with its purpose ('receive push notifications'), and distinguishes from sibling setup_aoi_monitoring by referencing monitor_id dependency.

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

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

It explicitly states a prerequisite ('Requires an active monitor_id from setup_aoi_monitoring'), giving clear context for when to use the tool. However, it does not mention when not to use it or alternatives like polling via get_notification_status.

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

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

No annotations are provided, so the description carries the burden. It discloses that the operation is pre-commitment and returns an itemized estimate, which is useful behavioral context. However, it does not mention side effects, authentication, or other potential behaviors beyond the fact that it is not a binding commitment.

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, front-loaded with the main action ('Returns itemized pricing'), and every word earns its place. The first sentence describes the function, the second provides usage guidance. No unnecessary 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?

Given the tool's moderate complexity (nested aoi object, 3 params, no output schema), the description covers the essential aspects: what it does, key inputs, and when to use it. It could additionally describe the output structure or potential limitations, but the existing information is reasonably complete for a pricing estimate tool.

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

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

The schema description coverage is 100%, so the parameters are already well-documented. The description merely mentions 'scene, AOI, resolution' in the text, which adds no new meaning beyond what the schema provides. Baseline of 3 is appropriate.

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

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

The description clearly states the tool returns itemized pricing for an archive order with explicit parameters (scene, AOI, resolution). It distinguishes itself from siblings by emphasizing 'before commitment' and 'cost estimate' as opposed to a binding quote, making its role unique.

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 says 'Use this to give the user a cost estimate before generating a binding quote,' which gives clear context for when to use it. It implies exclusion of binding quotes, though it does not name the alternative tool (e.g., quote_archive_order) directly.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. The term 'cost preview' implies non-committal estimation, which adds some context. However, it does not describe return format, potential side effects, or any limitations, leaving important operational details undisclosed.

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

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

The description is two concise sentences with zero waste. It front-loads the main purpose ('Estimate the cost...') and then gives usage timing, making it easy to parse.

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

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

The tool has no output schema and no annotations, and the description omits what the estimated cost output looks like or any additional behavioral details. While the schema thoroughly documents parameters, the description could clarify the return format or optionality for a more complete understanding.

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

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

The schema has 100% description coverage for all three parameters (aoi, sensor_type, resolution_tier), providing clear semantics. The description adds no additional parameter-specific information, so the baseline score of 3 is appropriate.

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

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

The description clearly states the tool's purpose with a specific verb ('Estimate') and resource ('new satellite capture tasking order'). It distinguishes from sibling tools like estimate_archive_price and quote_tasking_order by focusing on the cost preview stage.

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 instructs when to use the tool: 'before checking feasibility or generating a quote'. It provides clear context but does not enumerate alternatives or exclusions, so it falls short of a full 5.

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

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

Annotations already mark destructiveHint=true, which signals a mutating action. The description adds behavioral context by specifying that this is an irreversible commit requiring explicit user confirmation and safe retry with an idempotency_key. However, it does not explicitly disclose the financial impact or cancellation policy beyond 'place an order,' and the mention of idempotency_key is not backed by an actual parameter 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 three sentences, front-loaded with the purpose, followed by preconditions in a numbered list and a strong usage warning. Every sentence adds value and the structure makes it easy to scan. No redundant content.

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

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

The description covers the approval flow and preconditions, which is essential for a committed order tool. However, it does not explain what the agent should expect after execution (e.g., order ID, status) and, more importantly, the mismatched parameters (quote_id, idempotency_key) create a gap between the stated context and the actual schema. With no output schema, the description should at least align with the input contract, which it fails to do.

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?

Although the schema has 100% description coverage, the tool description introduces parameters (quote_id, idempotency_key) that do not exist in the input schema. This can mislead the agent into thinking it must provide fields that are not accepted. The description does not add useful meaning to the actual parameters (archive_id, aoi, label, user_confirmed) beyond what the schema already provides, and the mismatch actively harms parameter understanding.

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

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

The description clearly states the action: 'Place an archive order using a confirmed quote.' This distinguishes it from quote_archive_order (which creates a quote) and execute_tasking_order (which places a tasking order). However, the mention of 'quote_id' is confusing because the input schema does not include a quote_id parameter, slightly muddying the 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 provides explicit preconditions and usage boundaries: a valid quote_id is required, user confirmation is mandatory, and an idempotency_key is needed for retries. It explicitly states 'Do NOT call this tool autonomously — always wait for user confirmation,' and references 'quote_archive_order' as the source of the quote. This gives excellent when-to-use versus 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?

The destructiveHint annotation already signals mutating behavior. The description adds meaningful context: it must not be called autonomously, requires user confirmation, and needs an idempotency key. This goes beyond the annotation, though it doesn't cover failure modes or return behavior.

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

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

The description is two sentences: the first states the purpose, the second lists preconditions and a warning. It is front-loaded, concise, and every sentence carries critical information 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 complex tool with 8 parameters, the description omits that quote_id and idempotency_key are not in the schema, creating a significant invocation gap. It also does not clarify the order lifecycle or confirmation details. The schema fills in parameter semantics, but the mismatch hurts overall completeness.

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

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

Although schema coverage is 100%, the description references quote_id and idempotency_key as essential preconditions, but these fields are absent from the input schema. This mismatch confuses parameter understanding and the description does not map actual schema parameters to the preconditions, reducing its added value.

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 'Place' with the resource 'tasking order' and clarifies the requirement for a confirmed quote. This distinguishes it from sibling tools like execute_archive_order and quote_tasking_order, making the purpose unambiguous.

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

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

The description explicitly lists preconditions: valid quote_id from quote_tasking_order, explicit user confirmation, and idempotency_key. It also provides a clear exclusion: 'Do NOT call this tool autonomously — always wait for user confirmation.' This is strong when/when-not 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?

No annotations are provided, so the description carries the full burden. It states the action ('browse') and filtering capabilities but does not disclose pagination behavior, return format, or whether the operation is read-only. The schema indicates page and limit parameters, but the description adds no behavioral nuance beyond the obvious.

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

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

Two concise, front-loaded sentences. The first defines the tool's function, the second gives usage context. No wasted words or redundant restatements of the schema.

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

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

With no output schema and no annotations, the description leaves the return value implicit. It correctly identifies the tool's purpose and filter options, but does not explain what the response looks like or that pagination is possible. This is a minor gap for a simple browsing tool, but could be more informative.

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 50% (region and provider have descriptions). The tool description mentions both provider and region as filters, adding slight context, but page and limit are left undefined in both schema and description. For a list-browsing tool, page/limit are self-explanatory, so this is adequate but not exceptional.

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 ('Browse') and resource ('freely available datasets on SkyFi'), and clarifies the distinction from siblings by emphasizing 'free or open' data. This clearly differentiates it from tools like search_archive or purchase-related tools.

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

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

The description provides an explicit usage directive: 'Use this when the user asks about free or open satellite data.' This gives a clear trigger condition, though it does not explicitly name alternative tools or exclusion criteria, which prevents a perfect score.

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

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

With no annotations, the description carries the burden of transparency. It indicates a read-only action by returning a URL and metadata, but does not disclose any potential caveats like URL expiration, authentication, or errors. This is acceptable for a simple fetch tool but leaves gaps.

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

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

The description is two sentences, front-loaded with the primary purpose and followed by a usage directive. Every word is purposeful with no redundancy or unnecessary detail.

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

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

For a single-parameter read tool with no output schema, the description gives sufficient context: it states the return type (download URL and metadata), the condition (completed order), and the use case. While it could elaborate on the metadata structure, it is functionally complete for an agent to invoke.

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 provides a description for order_id ('Order ID of a completed order') with 100% coverage. The tool description repeats the 'completed/delivered' constraint but adds no additional parameter meaning beyond the schema, so the baseline of 3 applies.

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

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

The description clearly states the tool's action: 'Return download URL and metadata for a completed order's imagery.' It specifies a specific verb and resource, and the reference to 'imagery' distinguishes it from sibling tools like get_order_status.

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

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

The description explicitly says 'Use this when the user wants to download or access imagery from a delivered order,' providing a direct condition for when the tool should be used. This gives clear guidance without needing to reference 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?

With no annotations, the description carries the full burden. It states the core behavior (accepts string, returns lat/lng) but does not disclose potential failure modes (e.g., ambiguous locations, no match) or the return format (single pair vs. list of candidates). This is adequate but not rich.

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

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

Two sentences, each earning its place: the first defines the operation, the second gives a usage scenario. No fluff, front-loaded with the key term.

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

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

For a simple one-parameter tool with no annotations and no output schema, the description is complete enough: it explains what, how, and when. Minor omission is the exact output format, but that's not critical for a basic geocode.

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 fully describes the 'query' parameter with a clear example, and the description repeats that example but adds no new semantic meaning beyond the schema. Baseline 3 is appropriate given 100% 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 starts with 'Forward geocoding' which is a specific verb+resource pair, and clearly states it accepts a location string and returns coordinates. It distinguishes from the sibling reverse_geocode by explicitly naming 'Forward' versus implicitly reverse.

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 a clear when-to-use scenario: 'when the user mentions a place by name and you need coordinates for search or ordering tools.' However, it does not explicitly exclude reverse geocoding or mention the alternative sibling, so it stops short of a 5.

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

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

No annotations are provided, so the description carries the full burden. It discloses only the basic return type ('GeoJSON polygon') and the intended downstream use, but does not mention error behavior, side effects, authentication, or limitations. This is minimal behavioral disclosure.

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

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

Two sentences, front-loaded with the primary action, and no filler. Every word contributes to understanding the tool's purpose and usage.

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

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

For a simple single-parameter tool, the description is almost complete: it states the return type (GeoJSON polygon) and the use case (AOI for search/order). It lacks details like error handling or coordinate reference system, but these are not critical for an AI agent to invoke the tool correctly.

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

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

The input schema already fully documents the single 'query' parameter with a clear description ('A named place to look up a bounding box for'). The tool description adds no new parameter-specific meaning, so the baseline of 3 applies.

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

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

The description clearly states the tool 'Returns a bounding box polygon for a named place' with a specific verb and resource. The phrase 'directly usable as an AOI in search and order tools' adds a distinguishing use-case, differentiating it from siblings like geocode that return coordinates rather than polygons.

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

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

Explicitly instructs 'Use this to convert a place name into a GeoJSON polygon for subsequent tool calls,' providing clear context for when to invoke it. It does not list explicit exclusions or alternatives, but the usage intent is unmistakable.

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

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

No annotations are provided, so the description carries the full burden. It implies a read-only operation ('Check') and indicates the tool returns historical delivery information, but it does not disclose details such as return format, pagination, required permissions, or rate limits. For a simple getter, this is adequate but could be richer.

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

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

The description is two concise sentences. The first sentence states the purpose, and the second gives a concrete use case. No unnecessary words or repetition; every sentence earns its place.

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

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

The tool has two optional filter parameters and no output schema, but the description does not mention that filtering by monitor or subscription is possible, nor does it describe what the returned status/history looks like. This leaves gaps for an agent trying to use the tool effectively, though the core purpose is clear.

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

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

The input schema fully describes both parameters (monitor_id and subscription_id) with 'Filter by...' descriptions, providing 100% coverage. The tool description adds no parameter-specific meaning beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description clearly states the tool's function: 'Check delivery history and status for webhook subscriptions.' This uses a specific verb ('Check') and a specific resource ('delivery history and status for webhook subscriptions'), distinguishing it from siblings like create_webhook_subscription (creation) and get_order_status (order status).

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

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

The description provides explicit usage context: 'Use this to verify notifications are being delivered or to diagnose delivery failures.' This tells the agent when to invoke the tool, though it does not explicitly name alternatives or exclusion cases. The guidance is clear and actionable.

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

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

No annotations are provided, so the description carries the full burden of disclosing behavioral traits. It only states that it returns status and progress, which is essentially a paraphrase of the tool name. It does not mention whether the operation is read-only (though implied), any required permissions, potential errors, or what happens for invalid order IDs. This is a significant gap given the lack of 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 the primary action stated first and the usage context second. It is concise, front-loaded, and contains no unnecessary information. Every sentence earns its place.

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

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

For a simple single-parameter get tool with no output schema, the description covers purpose and usage but lacks detail about the return structure or error behavior. Since there is no output schema, the agent may not know what 'status' and 'progress' look like, but the tool's simplicity somewhat mitigates this. Overall, it is adequate but has clear gaps.

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

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

The schema already fully describes the single parameter 'order_id' with 100% coverage. The description adds contextual meaning by specifying that it is for 'a previously placed order,' which helps the agent understand that the ID refers to an existing order. This adds slight value beyond the schema's basic 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 the tool's function: 'Return current status and progress for an order by ID.' The verb 'return' is specific, and the resource is clearly an order. It conveys scope (status and progress) but does not explicitly distinguish itself from sibling tools like 'list_orders' or 'get_notification_status', though the focus on order status is implied.

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 direct usage instruction: 'Use this to check on a previously placed order.' This provides clear context for when to use the tool. It does not mention exclusions or alternative tools, but the context is explicit enough for an agent to select this tool for checking order status.

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

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

No annotations are provided, so the description must carry the burden. It clarifies the read-only scope by saying 'user's historical orders', but it doesn't mention pagination behavior, default ordering, or response shape. This is adequate for a simple list tool 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?

The description is concise and front-loaded, with two sentences. The first states the purpose, and the second adds usage guidance. There is slight redundancy between 'historical orders' and 'past orders', but overall it is efficient.

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 4 parameters including a nested object and no output schema, the description omits critical details like pagination semantics and return format. The agent cannot fully understand how to use page/limit or what the response will contain, so the tool is under-described.

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

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

Schema description coverage is only 25%, and the description merely mentions 'filters for date range and status', which is already evident from the schema. It doesn't explain the meaning of page and limit parameters, which are effectively undocumented. The description adds little 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 the verb 'List' and the resource 'user's historical orders', with specific filters for date range and status. This distinguishes it from sibling tools like get_order_status, which presumably targets a single order.

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 provides a direct use case: 'Use this when the user asks about their past orders or order history.' However, it doesn't explicitly mention when not to use it or point to alternatives like get_order_status for single order status, so it's clear but lacks 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It explains the return value (quote_id valid 15 minutes, human-readable summary) and the required confirmation workflow. It does not, however, state whether the quote has server-side side effects or what happens on expiration, but what it does disclose is valuable and goes beyond basic schema information.

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 exceptionally concise—two sentences that are front-loaded with the core purpose. Every clause provides critical information: the binding nature, return format, expiration, and the required confirmation step. No word is wasted.

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

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

For a tool with five parameters, no output schema, and no annotations, the description covers the essential context: what the tool returns, how long it's valid, and the required follow-up action. It does not explain parameter inputs, but the schema fully covers those. The description is sufficient for an agent to use the tool correctly, though it could mention error conditions or non-binding alternatives.

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 five parameters are fully described in the input schema, so the schema provides 100% coverage. The description adds no additional parameter-specific meaning beyond what the schema already conveys, which meets the baseline expectation for this dimension.

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 function with a specific verb ('Generate') and resource ('binding quote for an archive order'). It distinguishes itself from the sibling execute_archive_order by indicating the quote must be confirmed before execution, making its role in the workflow 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 provides clear usage context: generate a quote, present it to the user, and wait for explicit confirmation before calling execute_archive_order. While it implies this is a pre-execution step, it does not explicitly mention when to use this instead of the similarly named estimate_archive_price tool, though 'binding' hints at the distinction.

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

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

No annotations exist, so the description carries the transparency burden. It discloses that the quote is 'binding', returns a quote_id and summary, and requires feasibility check and user confirmation before execution. This adds meaningful behavioral context beyond basic functionality, though it doesn't detail cancellation or expiration policies.

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

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

The description is three sentences: purpose and return value, precondition, and next action. Every sentence adds essential information without redundancy or filler. It is well-structured and front-loaded with the primary purpose.

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

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

With no output schema, the description mentions the return (quote_id and summary) and the critical workflow. It references sibling tools (check_capture_feasibility, execute_tasking_order) for context. Minor gaps like error cases or quote expiration could be added, but the description covers the essential usage pattern adequately.

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 parameters are fully documented in the schema (aoi, resolution, product_type, window_start, window_end). The description does not add additional parameter-specific semantics, but the baseline of 3 is appropriate because the schema carries the 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 specifies a clear verb with a resource: 'Generate a binding quote for a new satellite capture tasking order.' It distinguishes this from sibling tools like quote_archive_order (archive orders) and estimate_tasking_cost (non-binding estimates) by using 'binding quote' and 'capture tasking order'.

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?

Explicit workflow guidance is provided: 'Precondition: call check_capture_feasibility first and present results to the user.' It also states the follow-up: 'Present this quote to the user and wait for confirmation before calling execute_tasking_order.' This clearly indicates when to use the tool and what to do before/after.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions ranking strategies and budget but does not state whether this is a read-only analysis, what the return structure looks like, or how the budget filter is applied. The name implies 'recommend' (non-executing), but the description should explicitly clarify side effects (or lack thereof).

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: the first defines the core action, the second gives usage context. Every word contributes, no 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?

This tool has 4 parameters, no output schema, and no annotations. The description gives the workflow position and core purpose, but lacks details about the return format (e.g., ranked list of scene IDs with scores), tie-breaking behavior, or handling of invalid candidates. Given moderate complexity, it is minimally adequate but with notable gaps.

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

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

Schema description coverage is 100%, so the baseline is 3 per guidelines. The description reinforces the strategy enum ('cost, quality, or balanced') and the budget concept, but does not add new parameter details beyond what the schema already provides. It adds modest value by framing the parameters in a business context.

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

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

The description states a clear verb ('Rank') and specific resource ('candidate archive scenes'), and further clarifies the ranking criteria (cost, quality, balanced) and the goal ('pick the best scene under an optional budget'). This distinguishes it from sibling tools like search_archive or execute_archive_order.

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 says 'Use this after search/pricing', giving a concrete workflow context. It does not explicitly name alternatives or state when not to use, but the instruction clearly positions this tool as a downstream decision step, which is sufficient 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?

No annotations are provided, so the description carries full burden. It states the output (a place name) but does not mention error behavior, return format, or any side effects. Since this is a simple lookup, a basic description is acceptable, but it lacks detail about what exactly is returned or how invalid inputs are handled.

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

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

Two sentences with no wasted words. The description is front-loaded with the action ('Returns a place name') and immediately gives the usage context. Perfectly concise.

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

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

For a simple tool with full parameter schema and no output schema, the description is nearly sufficient. It lacks detail on the output format (e.g., string vs. structured object), but given the simplicity and that the output is just a 'place name,' a 4 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%, and the schema already provides clear descriptions for both lat and lon. The description adds only the phrase 'coordinate pair,' which does not enrich parameter understanding beyond what the schema already states. Baseline 3 is appropriate.

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

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

The description clearly states the tool returns a place name for a coordinate pair, using a specific verb and resource. It distinguishes from sibling geocode (forward geocoding) by emphasizing the direction (lat/lng to place name).

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

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

Explicitly states the use case: 'Use this when you have lat/lng coordinates and need a human-readable location name.' This implies the alternative (geocode) is for the reverse direction, making the intended usage very 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?

With no annotations, the description carries the full burden. It discloses output contents (IDs, capture dates, cloud cover, preview URLs, pricing) and implies a read-only search, but it lacks details on pagination behavior, defaults, ordering, or error conditions. It provides some useful behavioral context but not a complete picture.

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 compact sentences: the first states the action and filters, the second covers return values and usage. There is no fluff or redundancy; it is well-structured and front-loaded.

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

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

The description covers the main purpose, key filters, and output fields, which is adequate. However, given the tool's complexity (nested AOI object, pagination, multiple enums) and the absence of output schema or annotations, it leaves important gaps around pagination behavior, parameter formats, and the exact meaning of 'available' imagery. It is sufficient 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?

Schema coverage is 50%, so the description should compensate. It names the main filter dimensions (AOI, date range, resolution, sensor type) but omits pagination parameters (page/limit) entirely. It does not explain enum meanings or input formats beyond what the schema provides, leaving gaps for less obvious parameters.

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

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

The description uses a specific verb 'Search' with a clear resource 'available satellite imagery' and enumerates filter dimensions (AOI, date range, resolution, sensor type). It also lists return contents, distinguishing it from tasking-related siblings like quote_tasking_order and fetch_order_image.

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 final sentence explicitly states usage: 'Use this as the first step when the user wants to find existing imagery.' This gives clear when-to-use context but does not mention alternatives or when not to use, so it falls short of the strongest 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?

With no annotations provided, the description carries the full burden for behavioral disclosure. It adds context about recurring monitoring and notification frequency, but does not disclose side effects such as creating persistent subscriptions, lifecycle management, or potential costs. It provides moderate behavioral insight but leaves gaps.

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 tight sentences: the first names the action, the second clarifies usage. Information is front-loaded, with no redundant or filler words. It is appropriately brief while conveying necessary context.

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

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

The tool has moderate complexity (4 params, nested AOI object, no output schema). The description covers the purpose, key configurable aspects, and a concrete usage scenario. It could also mention expected output or how to manage the monitoring, but given the schema fills in param details, the description is largely sufficient.

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

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

Schema coverage is 100%, so the baseline is 3. The description restates that sensor, resolution, and notification frequency are configurable, but does not add deeper semantics beyond what the schema already states. It reinforces the tool's purpose but offers no extra parametric 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 uses a specific verb-resource pair ('Configure recurring monitoring of an AOI') and clearly specifies the domain (new imagery). It distinguishes this from sibling tools by focusing on ongoing alerting rather than one-time search or order, 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?

It explicitly states the intended use case with 'Use this when the user wants to be alerted when new imagery becomes available over a specific area.' This gives clear context, though it does not mention when-not to use it or name alternative tools, so it stops short of a fully explicit exclusion/inclusion matrix.

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