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

Annotations already indicate write, non-idempotent, non-destructive behavior. The description adds useful context: it is the only write operation, and it explains the timing difference between ONGOING (data starts next day) and ONE_TIME_SNAPSHOT (returns historical data). It does not elaborate on repeated calls, but does not contradict 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, no redundancy. The purpose is front-loaded, followed by critical context (only write op, requirement), then mode-specific behavior. 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 description covers purpose, necessity, and mode behavior. An output schema exists, so return format is covered. The only minor gap is the lack of guidance on repeated calls, but annotations signal non-idempotency, so this is not critical.

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 parameters are documented. The description adds value by explaining the behavioral difference between the two access_type values, which goes beyond the schema's terse description. This helps an agent choose the right mode for the desired outcome.

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 ('enable analytics reports') and the resource ('report request'), and distinguishes it from all sibling tools by noting it is the only write operation. It also explains the requirement per app, making its purpose 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?

It explicitly identifies this as the required write operation for enabling reports, and contrasts it with the listing tools in the sibling set. It does not explicitly say 'use this instead of X', but the context is clear. It could mention what happens if called multiple times, but the necessity is well-stated.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, covering the safety profile. The description adds that results are returned as parsed rows rather than raw files, but does not disclose further behaviors such as pagination, decompression handling, or date-range semantics.

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 that front-loads the action and resource, then adds the relevant semantic detail about payments/proceeds and parsed rows. No filler or redundant repetition of schema 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 a rich output schema, full parameter documentation, and safety annotations, the description covers the essential call context. It does not mention how to choose among sibling download tools, but that is a usage-guidance gap rather than a completeness gap for invoking this tool correctly.

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

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

Schema description coverage is 100% for all 6 parameters, including defaults and allowed values. The description adds no unique parameter semantics, so the baseline of 3 applies since the schema does the heavy lifting.

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 ('Download'), a resource ('finance report'), content ('payments and proceeds'), and output format ('parsed rows'). This clearly distinguishes it from sibling tools like download_sales_report or download_report_instance.

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 finance reports via 'payments and proceeds', but gives no explicit guidance about when to choose this over siblings such as download_sales_report or download_report_instance. It provides context but no exclusions or alternative routing.

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, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds behavioral context by stating 'every segment', which implies the tool automatically handles all segments, and 'parsed rows', indicating transformation. However, it doesn't disclose potential performance implications, rate limits, or how truncation behaves beyond what the schema already covers. With annotations present, 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 a single, front-loaded sentence with zero filler: 'Download every segment of a report instance and return the parsed rows.' Every word adds value, and it is appropriately sized for the tool's complexity.

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 100% schema coverage, existing output schema, and annotations, the description is largely complete. It states the core action and scope ('every segment', 'parsed rows'), while the schema covers parameter semantics and the output schema covers return format. It doesn't mention any caveats like potentially large responses, but the max_rows and max_bytes parameters in the schema already address that. A small gap is the lack of context on what a 'report instance' is, though instance_id's source is documented in the schema.

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

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

Schema description coverage is 100%, so the schema fully documents all three parameters (instance_id, max_rows, max_bytes) including their defaults and purposes. The description does not add any parameter-level meaning beyond what the schema already provides, so the baseline 3 applies.

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

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

The description uses a specific verb ('Download') and a specific resource ('every segment of a report instance') and clarifies the output ('parsed rows'). This clearly distinguishes the tool from siblings like list_report_segments (listing vs downloading) and download_sales_report/download_finance_report (which target specific report types, not arbitrary report instances).

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. It doesn't mention prerequisites, exclusions, or sibling tools such as download_sales_report or list_report_segments, nor does it state that this is the tool for obtaining full report instance data as opposed to other download tools. The only implied usage is that it downloads report instances, but that's not sufficient to route an agent correctly.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds useful behavioral context: it returns parsed rows (not raw file bytes), covers specific metrics, and implies decompression via the max_bytes parameter. It doesn't mention pagination or row limits, but the schema covers max_rows. This is solid but not exhaustive.

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 filler. The first sentence states the action and output format; the second lists covered metrics and points to the sibling for valid combinations. 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 an output schema, 100% parameter coverage, and annotations covering safety, so the description doesn't need to explain return values or safety. It covers the report content and points to the sibling for valid combinations. The only minor gap is not explicitly stating that this is for App Store Connect sales reports, but the sibling names and vendor_number parameter make that 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?

Schema description coverage is 100%, so the schema already documents all 8 parameters. The description adds context about the report content (units sold, proceeds, etc.) and points to list_sales_report_types for valid combinations, which helps with report_type/report_sub_type semantics. However, it doesn't add much beyond the schema for individual parameters, so baseline 3 is appropriate.

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

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

The description states a specific verb ('Download') and resource ('Sales and Trends report'), and clarifies the output format ('parsed rows'). It also lists the metrics covered, which distinguishes it from finance reports and other report tools. The reference to list_sales_report_types for valid combinations further disambiguates it from siblings.

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

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

The description clearly indicates when to use this tool: to download a Sales and Trends report and get parsed rows. It points to list_sales_report_types for valid combinations, which is a form of alternative guidance. However, it does not explicitly state when not to use it (e.g., for finance reports or report instances), so it falls short of a 5.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds useful behavioral detail beyond those annotations: it resolves the request, looks up the report by name, selects the latest instance unless overridden, and downloads all segments. This gives the agent an accurate mental model of the operation's internal flow.

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

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

The description is compact and well-structured: a one-sentence summary of the full pipeline, followed by a two-sentence elaboration of the steps and the prerequisite. Every sentence contributes information, and the most important context 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 complex tool with 7 parameters and an output schema, the description covers the essential workflow: request resolution, report lookup, instance selection, segment download, and the list_reports prerequisite. Remaining parameter details are fully documented in the schema, and return values are covered by the output schema, so nothing critical is missing.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value beyond the schema by explaining semantic relationships: report_name must be exact and can come from list_reports, while processing_date defaults to the latest instance unless provided. This helps the agent choose and populate the right 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 opens with a specific verb and resource: 'Fetch one analytics report end to end: request, report, instance, rows.' It clearly names the pipeline of objects involved and distinguishes this from the sibling list_* and download_* tools by framing it as an end-to-end fetch.

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

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

The description gives clear context and a concrete prerequisite: 'Call list_reports first if you do not know the exact report name.' It also explains the default instance-selection behavior. However, it does not explicitly state when to prefer this tool over closely related siblings like download_report_instance.

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 idempotentHint=true, so the agent knows this is a safe read. The description adds useful context: metrics are aggregated from devices that opted into sharing diagnostics, and it covers 'recent versions', implying data scope. However, it does not disclose response size, pagination, or any other operational traits beyond these caveats. The added context is valuable but not extensive.

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 main purpose, and the second sentence adds relevant context (metric coverage and data source). No fluff or repetition. Every word earns its place.

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

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

Given the tool's moderate complexity (4 parameters, 1 required) and the existence of an output schema, the description covers the core purpose, data scope, and aggregation source. It does not mention potential pitfalls or usage scenarios, but the schema and annotations fill most gaps. Slightly more detail on result granularity could push it to 5, but it is adequate as is.

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

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

Schema description coverage is 100%, so all four parameters are well-documented in the input schema. The description repeats some metric names but adds little beyond the schema's own details (e.g., app_id is already explained as from list_apps, metric_type enum already lists options). Per calibration, with high schema coverage the baseline is 3, and the description doesn't compensate with extra 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 verb 'get' and the resource 'Xcode power and performance metrics of an app's recent versions'. It also enumerates the specific metric categories (launch time, hangs, memory, disk writes, battery, terminations), making it unambiguous what the tool retrieves. This distinguishes it from the sibling report/list tools which focus on reports, sales, finance, and reviews.

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

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

The description implies usage when power/performance metrics are needed, but it does not explicitly state when to use this tool versus alternatives like fetch_analytics_report or other analytics tools. No exclusions or conditions are provided. The agent can infer the purpose 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 declare readOnly/idempotent/non-destructive behavior. The description adds value by clarifying that results are scoped to the configured API key and that the primary output is numeric app IDs consumed by sibling tools.

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, front-loaded with the core behavior and followed by the use-first guidance. 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?

Given strong annotations, a complete output schema, and full parameter documentation, the description covers everything needed to select and invoke the tool correctly. It even explains why the agent would call it first.

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

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

Schema description coverage is 100%, with each parameter already documented (name, limit, cursor, bundle_id). 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?

Description states a specific verb ('List'), a clear resource ('the apps the configured API key can access'), and the purpose of discovering numeric app IDs for other tools. This distinguishes it from the report-focused siblings without ambiguity.

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

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

The description gives explicit guidance: 'Use this first' to discover app IDs needed by other tools. It doesn't spell out when not to use it, but the sibling tools operate on different resources, so no exclusions are necessary.

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, idempotentHint=true, and destructiveHint=false, so the safety profile is covered without the description. The description does not go beyond that to mention pagination via cursor, sort/rating/territory filters, or the paged default behavior, though the schema documents these details.

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

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

The description is a single, front-loaded sentence that states exactly the operation and object with no filler or repeated information. 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?

Combined with a fully self-describing schema, annotations, and an output schema, the one-line description is sufficient to understand the tool's purpose. It could add a pointer to list_apps for obtaining the app_id, although the parameter description already supplies that link.

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

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

Schema description coverage is 100%, so each parameter already carries its own detailed description; the tool description adds no parameter-specific meaning. The baseline of 3 applies because the schema does the heavy lifting and the description need not repeat 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 names a specific verb (List) and a unique resource (App Store customer reviews) scoped to an app, which distinguishes it from the report-oriented sibling tools. Even without reading the schema, an agent can tell exactly what this tool retrieves.

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 use case clear—list App Store reviews for an app—and the schema source for app_id references list_apps, giving a useful precondition. It does not explicitly discuss when-not-to-use it or call out alternatives, but no sibling tool appears to offer a competing review-listing path.

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, idempotentHint=true, and destructiveHint=false, so the safety profile is clear. The description adds useful context about the nature of the data (commonReports vs. Detailed reports, pre-aggregated vs. larger detailed reports), which goes beyond the annotations. However, it doesn't describe the exact structure of the response or any potential variability in the output format.

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 well-structured, with the main purpose stated first, followed by clarifying details about the difference between commonReports and Detailed reports. It earns its place by providing useful context without unnecessary verbosity.

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 that the tool has no parameters and an output schema exists, the description is fairly complete. It explains the purpose, the distinction between report types, and points to a sibling tool for further detail. It could be slightly more explicit about the response structure, but the output schema likely covers that.

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

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

The tool has zero parameters, so the schema is trivially complete. The description adds value by explaining what the tool returns and how the API is structured, which is more than the schema alone provides. Since there are no parameters, the baseline is 4, and the description meets that.

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

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

The description clearly states the tool's purpose: describing Analytics Reports categories and API structure. It distinguishes itself from sibling tools by explicitly mentioning list_reports for confirming the full set of reports, which helps differentiate it from the related list_reports 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?

The description provides clear context on when to use this tool: to understand the categories and API structure, and it explicitly directs users to list_reports for the full set of reports. It doesn't explicitly state when not to use it, but the guidance is sufficient for an agent to select it appropriately.

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

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

Annotations already cover the safety profile (read-only, idempotent, non-destructive). The description adds the useful invariant that results are defined per granularity and processing date, but it doesn't disclose pagination or any other runtime behavior. This is appropriate but modest given the annotation coverage.

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

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

A single sentence with no filler; the most important scoping concept is front-loaded. It is efficiently structured and easy to scan.

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 a fully self-describing schema, safety annotations, an output schema, and pagination parameters documented, the description does not need to repeat lower-level details. The only missing conceptual piece, the uniqueness of instances, is present in the opening sentence.

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 each parameter has a meaningful description (defaults, allowed formats, source of report_id). The tool description adds the 'one per granularity and processing date' context but no per-parameter semantics beyond the schema. This meets the baseline for well-covered parameters.

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

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

The description states a clear action ('List') and resource ('instances of a report'), and it clarifies the entity by adding 'one per granularity and processing date.' It is distinguishable from sibling list tools, but it doesn't explicitly name alternatives, so it falls just short of full differentiation.

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

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

The description provides a concise definition but no explicit when-to-use versus alternatives like list_reports or download_report_instance. The intended context can be inferred from 'instances of a report,' but the agent is not told when not to use this tool. That yields implied, rather than 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 already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds no behavioral context beyond listing, such as pagination behavior, ordering, or that access_type is an exact-match filter. It does not contradict 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 clear sentence with no wasted words. It is front-loaded with the verb and resource. It could add a brief note about filters or pagination, but it is appropriately concise.

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

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

The tool has an output schema, annotations, and full schema coverage, so the description does not need to explain return values or safety. However, it lacks guidance on pagination behavior, default limit, and how access_type filtering behaves, which an agent might need to know for correct invocation. It is adequate but not rich.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters. The description adds no extra meaning beyond what the schema provides, such as the relationship between app_id and list_apps or the meaning of access_type values. Baseline 3 is appropriate.

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

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

The description states a specific verb ('List') and resource ('analytics report requests') and scopes it to an app. It is clear enough to distinguish from siblings like list_reports or list_report_instances, though it does not explicitly name a sibling or contrast itself.

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

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

The description implies usage context: list report requests for an app, with an optional access_type filter. It does not explicitly state when to use this tool versus list_reports or list_report_instances, nor does it mention exclusions. The schema provides filter details, but the description itself offers no alternative routing.

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, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds the scoping behavior that reports are listed within a request, but it does not mention pagination or filtering behavior. No contradiction exists between the description and annotations.

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

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

The description is a single, front-loaded sentence with no filler. Every word contributes to identifying the operation and the expected scope, making it appropriately concise and well structured.

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

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

Given the tool's moderate complexity, the input schema fully documents all five parameters, and an output schema exists, the description is adequate when combined with the structured data. It establishes the core purpose and scope, though it leaves sibling relationship guidance to the usage dimension.

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

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

Schema description coverage is 100%, with every parameter documented in the input schema, so the baseline is 3 even though the description adds no parameter-level detail. The description does not otherwise clarify semantics for request_id, name, limit, cursor, or category beyond what the schema already provides.

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

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

The description uses a specific verb ('List') and names a clear resource ('reports') scoped to 'an analytics report request', so it is not a tautology and conveys the tool's core purpose. It implicitly distinguishes the tool from siblings such as list_report_requests and list_report_categories, though it does not explicitly name the 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 phrase 'inside an analytics report request' implies the tool should be used when the agent needs reports belonging to a specific request, but the description does not explicitly state when to use it versus alternatives. The schema's request_id description references list_report_requests and create_report_request, yet this routing context is not present in the description itself.

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 establish read-only, idempotent, and non-destructive behavior. The description adds meaningful extra context beyond those hints: segment URLs expire 5 minutes after the call, and large reports are split into multiple segments. This discloses a time-sensitive state change and points to a helper tool for consuming the result, which is genuinely useful.

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 filler. The core purpose is front-loaded, followed by the single most important behavioral caveat (URL expiration) and a pointer to the sibling downloader. 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?

Given that an output schema exists, the description does not need to detail return values. It already covers the tool's purpose, the segmenting behavior of large reports, URL expiry, and how to get parsed content. There is no missing operational context an agent would need to select and invoke this tool correctly.

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

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

Schema description coverage is 100%, so instance_id and limit are already documented in the schema (instance_id as 'ID from list_report_instances', limit as 'Segments per page (1-200)'). The description does not add additional parameter-level meaning beyond what the schema provides, so the baseline score of 3 is appropriate.

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

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

The description opens with a specific verb and resource: 'List the segments of a report instance, each with a download URL.' This clearly distinguishes the tool from siblings like list_report_instances (lists instances) and download_report_instance (downloads/parses), removing ambiguity about what this tool returns.

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

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

It gives clear context: large reports are split into segments, and this tool lists them. It also references the alternative behavior of download_report_instance, which 'fetches and parses them for you,' implying this tool is for obtaining raw segment URLs while the sibling handles automated fetching/parsing. It lacks an explicit 'use this when' or 'don't use when' statement, 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, idempotentHint, and destructiveHint. The description adds the specific constraint that the tool lists only valid combinations and that the API rejects others, which is beyond the annotations. There is no contradiction, and the description adds useful behavioral context about the validation rule.

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, well-formed sentence that states the action and the specific scope. It is front-loaded and contains zero wasted words. The clarification about rejection adds value without bloating the text.

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 zero parameters, an output schema present, and clear annotations, the description is complete. It tells the agent what the tool returns (valid combinations), how it relates to download_sales_report, and the consequence of invalid combinations. No additional information is needed for correct invocation.

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

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

The tool has zero parameters, so the schema provides no parameter details. The description explains the purpose but not parameter details (there are none). Per the rubric, a zero-parameter tool gets a baseline of 4, and the description appropriately explains the tool's role without needing parameter semantics.

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 (valid reportType/reportSubType/frequency/version combinations) and explicitly ties it to download_sales_report, distinguishing it from siblings like list_report_categories or download_finance_report. It leaves no ambiguity about what the tool does.

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

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

The description implies the primary use case: obtaining valid parameter combinations before calling download_sales_report, and warns that invalid combinations are rejected by the API. It does not explicitly name alternatives or say 'use this before download_sales_report,' but the context is strong and the tool's purpose is self-evident.

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