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

The description discloses that the tool replaces existing releases, implying destructive behavior. It also mentions validate_only to check without committing, so potential side effects are partially transparent. However, it does not detail all mutation consequences or authorization requirements, though annotations are absent.

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, consisting of three sentences that cover purpose, usage, and alternatives without fluff. It is well-structured and each sentence serves a clear function.

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

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

Given the tool's complexity, the description covers key aspects: action, prerequisites, alternatives, and safe validation. It does not explain every parameter, but the schema handles that. Overall, it provides enough context for a user to understand the tool's role and basic usage.

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

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

The schema fully documents each parameter, so the baseline is 3. The description adds meaning by explicitly instructing to obtain version codes from list_bundles or list_apks and mentions validate_only, which enhances understanding of these parameters. It does not cover all parameters but adds context 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 tool creates a release on a track from explicit version codes and replaces existing releases. It distinguishes from promote_release by specifying the difference, 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 states when to use this tool (to ship an already-uploaded bundle), how to get prerequisites (list_bundles or list_apks), and provides clear alternatives (promote_release) and a safe-check option (validate_only). This gives complete 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, the description must carry the transparency burden. It provides useful lifecycle context: built-in tracks are pre-existing, and track creation alone does not grant tester access or ship a release. However, it does not mention permission requirements, default commit behavior, validate_only effects, or what a successful response looks like.

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

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

The description is three concise sentences, front-loaded with the core action. Every sentence earns its place: what the tool does, when it is unnecessary, and what to do next. No redundant or vague phrasing.

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

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

Despite having no output schema or annotations, the description is mostly complete for selection and invocation: it specifies the track type, excludes built-in tracks, and explains the required follow-up steps. Minor gaps remain around commit/review semantics, but the schema documents those parameters.

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

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

Schema description coverage is 100%, and the parameter descriptions already explain track, form_factor, package_name, validate_only, and changes_not_for_review. The tool description adds useful workflow context but no additional parameter-specific semantics, so the schema-driven 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 identifies the action and resource: 'Create a new custom closed testing track.' It also distinguishes this tool from alternatives by noting built-in tracks already exist and cannot/should not be created, and by separating it from create_release.

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

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

The description explicitly states when to use the tool (creating a new custom closed testing track), when not to use it (built-in tracks already exist), and the follow-up workflow: use update_testers for Google Groups access and create_release to ship. This is strong practical 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 present, so the description carries the behavioral disclosure burden. It clearly indicates a read-only retrieval and enumerates the exact fields returned while excluding per-locale details. It does not cover auth, errors, or defaults beyond the schema, but for a simple getter the scope is well disclosed.

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

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

The description is a single sentence with no filler. It front-loads the action and resource, then lists the specific fields, making every word useful.

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 only one optional parameter and no output schema, the description gives enough information for selection and invocation: it names the returned fields and clarifies the non-locale scope. It could add response shape or explicit default-package behavior, but the schema covers the parameter and the tool is simple.

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

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

The description does not explain the package_name parameter, but the input schema fully documents it with an example and a default value, yielding 100% schema coverage. Therefore the baseline score of 3 is appropriate 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?

The description uses a specific verb ('Get') and identifies the resource as 'app-level details' while naming the exact fields returned (contactEmail, contactPhone, contactWebsite, defaultLanguage). It also explicitly contrasts these with per-locale data, which distinguishes it from locale-specific sibling tools like get_listing.

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 'not per-locale' provides clear context that this tool is for app-wide settings rather than locale-specific listing details, helping an agent choose it over get_listing. It does not explicitly name alternative tools or provide when-not-to-use conditions, but the implied scope is clear enough.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It explicitly says 'Read-only,' which tells the agent the tool does not mutate state. However, it does not mention potential errors, authentication requirements, or rate limits, but for a simple getter, this is adequate.

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 (two sentences) and front-loaded with the main purpose. It provides essential info without redundancy or unnecessary detail. Every phrase earns its place, including the read-only note and the pointer to alternative tools.

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 this is a simple read-only tool with only two parameters and no output schema, the description sufficiently explains what it does and what it returns (countries and restriction status). It also guides the agent on related actions, making it complete for the tool's complexity.

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

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

The schema has 100% description coverage for both parameters (track and package_name), so the schema already explains them. The description does not add extra meaning about parameters beyond that, but it does mention the output concept (restricted country list) which indirectly relates to the 'track' parameter. This matches the baseline of 3.

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 gets country availability for a track, including whether the app is restricted to a list and which countries are included. It uses a specific verb ('Get') and resource ('countries a track is available in'), and it differentiates from siblings by focusing on targeting status rather than release actions.

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 that the tool is read-only and directs users who want to change targeting to use the 'country_targeting' argument of create_release or promote_release. This gives clear when-to-use and when-not-to-use guidance, distinguishing it from modification tools.

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

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

With no annotations provided, the description carries the full burden. It explains the return structure (deviceGroups, deviceTierSet, userCountrySets) and adds semantic detail about device selectors. Although it doesn't disclose potential side effects or permissions, it is a read-only get operation and the description gives enough context for an agent to understand the behavior without contradictions.

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 fluff. The core action is front-loaded ('Get one device tier config by id'), followed by essential detail on the return contents and usage context. Every clause earns its place, making it highly 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 absence of an output schema, the description adequately describes the return shape by listing the contained entities. It also provides necessary context for obtaining the id and explains the Play Asset Delivery relevance. It lacks any mention of error conditions or permission requirements, but for a simple get operation with low complexity, this is 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% and both parameters are clearly described. The description repeats the parameter guidance for device_tier_config_id ('Get ids from list_device_tier_configs') but adds no new semantic detail beyond what the schema already provides. It does not mention package_name beyond the schema, so the description adds no marginal 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 verb 'Get' with the resource 'device tier config' is specific and clear. It explicitly mentions the included entities (deviceGroups, deviceTierSet, userCountrySets) and distinguishes itself from the sibling list_device_tier_configs by saying 'Get one... by id' and instructing to obtain ids from the list. This clearly differentiates its 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?

It explicitly tells the user to get ids from list_device_tier_configs, which is a direct alternative and prerequisite. It also provides context about Play Asset Delivery, implying when this tool is relevant. However, it does not explicitly state when not to use it or name other alternatives beyond the list tool, 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?

With no annotations, the description carries the full burden. It discloses the return fields (fileSize, referencesVersion) and an error condition (for app bundles). It implies read-only via 'Get' and provides important context about legacy vs modern app distribution, though it does not mention authentication, rate limits, or other side effects.

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

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

Two concise sentences: the first states the action and return values, the second adds usage caveat. No wasted words, front-loaded with the critical purpose. Excellent structure.

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

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

For a simple getter with no output schema, the description sufficiently explains what is returned, when it errors, and its legacy nature. All parameters are documented in the schema, and the description fills in the only missing context (the bundle caveat). It is complete given the tool's simplicity.

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

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

The input schema covers all 3 parameters with clear descriptions (package_name, apk_version_code, expansion_file_type), so baseline is 3. The tool description does not add extra parameter-level detail beyond the schema, though it does provide domain context about legacy APKs that might influence how parameters are used.

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 clear verb 'Get' and specifies the resource 'OBB expansion file attached to an APK version code', also stating the return values (fileSize and referencesVersion). It is specific and distinct from sibling tools, which focus on tracks, releases, reviews, etc.

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 notes this is a 'Legacy APK-only feature' and that apps using app bundles will 'get an error here', effectively telling agents when not to use it. However, it does not name an alternative sibling tool, only mentions 'asset packs' conceptually, so it lacks a direct alternative reference.

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 must carry behavioral info. It specifies the return fields but doesn't mention read-only nature, error conditions, or other implications. This is adequate for a simple getter but lacks richer context.

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

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

Two concise sentences: the first states the primary action and expected content, the second provides a usage tip. No extraneous words, efficiently 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?

Given the simplicity of the tool (two params, no nested objects, no output schema), the description is complete: it explains what it retrieves, scopes it to one locale, and advises when to use an alternative. The agent has sufficient information to invoke correctly.

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

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

The input schema fully documents both parameters (language and package_name) with clear descriptions, achieving 100% coverage. The description does not add parameter-specific details, but the baseline is 3 per the rubric.

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 retrieves a store listing for a specific locale, listing the exact fields returned (title, shortDescription, fullDescription, video). This distinguishes it from the sibling list_listings, which presumably retries all locales, by emphasizing 'one locale'.

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 guidance is provided: 'Use list_listings first if you do not know which locales exist.' This tells the agent when to use a different tool, which is a clear usage guideline.

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 full burden. It discloses that the tool is a list operation, filters to currently serving releases, and returns a specific nested structure (tracks[] with servingReleases[] and versionCodes) – giving insight into behavior. It does not explicitly state it's read-only or discuss rate limits, but for a simple metadata-fetching endpoint the implied read-only nature and clear output scoping are reasonably transparent.

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

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

Three sentences cover purpose, output structure, and usage guidance without wasted words. The information is front-loaded with the core action, followed by a compact description of the return shape, and closes with essential usage notes and alternatives. No filler or redundant phrasing.

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

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

Given the absence of an output schema, the description must explain the return shape and semantics. It details tracks[] with displayName, type, and servingReleases[] (displayName + versionCodes), and provides an example filter string ('versionCode = 415'). This is sufficient for a developer to use the tool correctly in the intended query_* workflow, covering both data structure and usage context.

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

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

The schema coverage is 100% (one parameter, package_name) with a clear inline description and example. The prose description does not repeat or enhance the parameter semantics, which is acceptable since the schema already fully documents it. Per calibration rules, this lands at the baseline of 3.

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 'List the tracks and releases that vitals metrics can be filtered by' – a specific verb+resource+scope combination. It explicitly differentiates from siblings list_tracks/list_releases by clarifying it returns only release-filter options and notes 'Only releases currently serving users are listed, so use list_tracks or list_releases for the full release picture.' This uniquely identifies the tool's purpose among many similar list/query 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 provides explicit when-to-use guidance: 'Use those version codes to build the filter argument of query_crash_rate, query_anr_rate and the other query_* tools.' It also names specific alternatives (list_tracks/list_releases) for when full release data is needed, and states the limitation ('Only releases currently serving users') to guide correct decisions.

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 must carry the full burden of transmitting behavioral details. It discloses what the return includes (the full comment thread), which is useful, but it does not mention whether this is a read-only operation, any authorization needs, or potential errors. This is acceptable for a simple getter 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 exactly two sentences, front-loaded with the primary action and then the return contents. It wastes no words and includes a critical workflow hint without redundancy.

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

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

For a simple getter tool with full schema coverage and no nested objects, the description provides all essential context: what it returns, how to identify the review, and where to obtain the ID. Lacking an explicit statement about being read-only is a minor omission, but the verb 'get' and the informative return description make it sufficiently complete.

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

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

The input schema provides 100% description coverage for all three parameters, including 'Review ID as returned by list_reviews' for review_id. The tool description repeats this source but does not add new parameter-level meaning beyond the schema, so the baseline of 3 is appropriate.

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

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

The description clearly states the tool 'Get a single user review by its reviewId' and specifies the return includes 'the full comment thread (user comment and any developer reply)'. It also distinguishes from sibling tools by noting review IDs come from list_reviews, making it unambiguous as a single-item retrieval 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?

It provides contextual guidance by explicitly stating 'Get review IDs from list_reviews', which tells the agent where to obtain input for this tool. It implies use when you need a specific review, but it does not explicitly discuss exclusions or when not to use it, so it earns a 4 rather than 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?

With no annotations, the description carries full responsibility for disclosing side effects. It says 'Get', implying a read-only operation, but does not explicitly state that no modifications occur. It also does not mention potential error cases or rate limits, but for a simple getter, this is acceptable. The lack of explicit side-effect disclosure is a minor gap.

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

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

The description is succinct, using two short sentences. It states the purpose and the key constraint without any unnecessary words. Structure is clear and 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?

For a simple getter with no output schema, the description provides sufficient context: what it does, the condition (closed track), and the return concept (googleGroups). It lacks details on error behavior or fallback defaults, but these are not critical for this type of tool. Overall, it is adequately complete.

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

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

The schema covers both parameters with descriptions (100% coverage). The description adds context about the track being closed and the return type (googleGroups), but these are partly redundant with the parameter descriptions. No significant additional semantics beyond the schema are provided.

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: retrieving Google Groups for a closed testing track. It uses the verb 'Get' and specifies the resource (Google Groups) and scope (closed testing track). While it doesn't explicitly contrast with the sibling 'update_testers', the read-only nature is implicit in 'Get'.

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 clear usage constraint: it only applies to closed tracks (alpha and custom tracks), not to internal or production. This helps the agent decide when to invoke the tool. However, it does not explicitly mention when to use an alternative like 'update_testers' for modifications, though the read-only implication is strong.

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 the return content (name, versionCodes, status, userFraction, releaseNotes) and implies a read-only operation through 'Get', but does not explicitly state that it has no side effects, requires permissions, or handles errors. For a simple get operation 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?

The description is two sentences, directly stating the purpose and the prerequisite step. It is concise, front-loaded, and contains no redundant information.

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

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

For a simple retrieval tool with two documented parameters and no output schema, the description sufficiently conveys what the tool does, what it returns, and when to use it. The field list compensates for the missing output schema, and the sibling context shows this is a distinct read operation.

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

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

Schema description coverage is 100%, so the description need not elaborate on parameters. It does not add information beyond the schema; the track and package_name parameters are fully documented in the schema. Baseline score of 3 applies.

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

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

The description clearly states the tool's function: 'Get a single release track with its releases' and enumerates the returned fields. It distinguishes itself from sibling list_tracks by specifying it's for a single track and explicitly mentioning list_tracks as a prerequisite.

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

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

Provides explicit usage guidance: 'Use list_tracks first if you do not know the track name.' This indicates when to use this tool versus the alternative list_tracks, clarifying the appropriate workflow.

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

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

No annotations are provided, so the description carries the full burden. It discloses the default metric sets, the return structure (freshnessInfo.freshnesses[]), the lag (about a day), and the error handling for missing metric sets. However, it does not describe the exact format of the error field or whether the tool can fail entirely, nor does it explain the top-level structure of the response (e.g., does it return a single object or a list?). It adds significant context beyond schema but lacks some detail on failure modes and response 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 a single paragraph of moderate length, but it is dense with useful information. It front-loads the primary purpose ('Check how fresh Android vitals data is'), then lists key details (defaults, lag, error handling). It avoids unnecessary wordsholiness and stays focused. A slight point is lost for being a bit long and not broken into bullet points, but it earns its length.

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 complexity of the vitals data ecosystem festooned with many query tools, this description is comprehensive. It explains the tool's role, output structure, default behavior, and error handling, which is sufficient for the agent to use it effectively. There is no output schema, so the description must explain what is returned, and it does. It also addresses edge cases like apps without certain metric sets. This is complete for the tool's scope.

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 covers 100% of parameters, including descriptions for both 'metric_sets' and 'package_name'. The description adds clarity about the default metric sets and the purpose of the tool, but does not add new syntax or format details for the parameters beyond what the schema already provides. For example, it doesn't specify the exact string values for the enums, but that's in the schema. Thus, 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's purpose: to check the freshness of Android vitals data before querying. It specifies the verb 'check', the resource 'Android vitals data', and the specific output 'freshnessInfo.freshnesses[]'. It distinguishes itself from the query_* siblings by explicitly positioning it as a preparatory step to pick valid end_date values.

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

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

The description explicitly states when to use this tool: 'before querying it', and gives a clear use case: 'use it to pick an end_date the query_* tools will actually return rows for'. It also explains the behavior when a metric set has no data (returns an error field instead of failing), guiding the agent to handle that case. It does not explicitly name alternatives, but the context of sibling query_* tools is clear, and it implicitly tells the agent to call this before those.

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. It transparently discloses the key behavioral trait: halting stops delivery to new users while preserving the current userFraction, and implies reversibility by recommending update_rollout to resume. It doesn't detail edge cases or side effects, but covers the core behavior well.

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 verb, zero fluff. The first sentence states the action and effect, the second provides the recovery path. Every word earns its place.

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

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

The tool has 4 parameters (1 required) and no output schema. The description covers the purpose, the effect on userFraction, and the follow-up action. It doesn't explain return behavior, but that's not critical for a straightforward mutation. It is complete enough for an agent to select and invoke correctly.

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

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

Schema description coverage is 100%, so all four parameters (track, package_name, validate_only, changes_not_sent_for_review) are already documented in the schema. The description adds no additional parameter-specific context beyond the schema, but doesn't need to thanks to high coverage. Baseline 3 is appropriate.

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

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

The description uses a specific verb ('Halt') with a specific resource ('in-progress staged rollout on a track') and clearly explains the effect ('stopping delivery to new users while keeping the current userFraction'). It also distinguishes from sibling update_rollout by recommending it for resume/complete, exceeding a basic purpose statement.

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

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

The description states when this is appropriate: for an 'in-progress staged rollout', and it explicitly directs to 'use update_rollout afterwards to resume or complete it' as the follow-up alternative. It doesn't explicitly contrast with promote_release or mention when not to use, but the context and follow-up provide clear 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 of behavioral disclosure. It successfully reveals the anomaly contents (name, metricSet, dimensions, metric, timelineSpec), the condition for inclusion (flagged only when the metric got worse), and pagination details (default 10, max 100, nextPageToken). This goes well beyond what the schema alone communicates, making the tool's behavior predictable.

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 well-structured paragraph of five sentences, each earning its place: definition, data structure, workflow guidance, pagination, and entry-point advice. It is front-loaded with the core purpose, and there is zero 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?

Despite lacking an output schema and annotations, the description is complete enough for an agent to invoke the tool correctly and process results. It covers the return fields, pagination behavior, and next steps (feeding into query_* tools). Given the moderate complexity (pagination, filter), the description fully compensates for missing structured output schema.

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

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

The schema already covers all 4 parameters with descriptions, so the baseline is 3. The description adds meaningful context beyond the schema: it explains what 'dimensions' represent (e.g., versionCode or deviceModel), clarifies the anomaly metric and timelineSpec, and reinforces how page_token works with nextPageToken. This enriches the schema rather than merely repeating it.

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

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

The description clearly states the tool's function: 'List anomalies Google detected in this app's vitals metrics' – a specific verb and resource. It also distinguishes this from sibling query_* tools by framing it as the entry point for checking current problems, and explains the anomaly data structure, making its exact 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 advises using this tool first ('Start here to check whether anything is currently wrong instead of guessing date ranges') and directs feeding results into the matching query_* tool for timelines. It gives clear contextual guidance on workflow placement, though it doesn't explicitly state when not to use it (e.g., if the exact metric is already known, one could go directly to query_*).

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 transparency burden. It clearly states what the tool returns (APKs with versionCode and binary hashes) and scopes the operation to uploaded APKs only. It does not mention auth or error behavior, but for a read-only listing tool the disclosed output and scope are reasonably sufficient.

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

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

The description is three short, purposeful sentences. It front-loads the core action and output, then gives alternative-tool guidance and downstream usage, with no filler or repetition.

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

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

For a low-complexity tool with one optional parameter and no output schema, the description provides the essential return fields, scope, and relationship to sibling tools. It offers enough context for an agent to select and invoke the tool correctly without needing additional output documentation.

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 package_name parameter is already documented in the schema. The description adds no new parameter-level semantics beyond referencing versionCode usage in a downstream tool, but that is output-related rather than parameter-related, so the high schema coverage keeps this at baseline.

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

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

The description uses a specific verb ('List') and names a specific resource ('APKs uploaded for an app'), along with the key returned fields (versionCode and binary hashes). It also distinguishes from the closely related list_bundles tool by clarifying the APK-vs-bundle difference.

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 explains when to use this tool versus an alternative: 'use list_bundles for those' when apps ship bundles. It also provides downstream guidance by pointing the agent to use versionCode values with create_release, which helps with workflow selection.

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

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

Discloses pagination behavior and a nuance about displayName, with no annotations to contradict.

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?

Concise and well-structured, front-loaded with purpose, then usage, notes, and pagination.

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?

Sufficient given lack of output schema; covers purpose, usage, notes, and pagination for a 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?

Adds some context about pagination and default/max, but schema already describes parameters clearly.

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?

Clearly states it lists apps accessible by the service account, with specific attributes, using a verb and resource.

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

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

Explicitly tells when to use it (discover package names) and contrasts with other tools by mentioning passing packageName to other tools.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the tool is a read-only listing operation (no upload capability), which is important behavioral context. It could add more about pagination or error cases, but the key behavioral trait (no uploads) is clearly stated.

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

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

The description is two sentences, front-loaded with the core purpose, and every sentence earns its place. It efficiently conveys the purpose, return fields, and usage guidance without any 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?

For a simple list tool with one parameter and no output schema, the description is complete. It covers what the tool does, what it returns, and how to use the results. It could mention whether the list is sorted or paginated, but given the simplicity, this is a minor gap.

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

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

The schema already provides 100% coverage for the single parameter (package_name) with a clear description and default behavior. The tool description adds no additional parameter semantics 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 clearly states the tool lists app bundles (AABs) for an app, specifying the returned fields (versionCode, sha1, sha256). It distinguishes itself from sibling tools like list_apks and list_generated_apks by explicitly focusing on AABs, and it connects to create_release for shipping bundles.

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: it tells the agent to use versionCode values with create_release to ship a bundle, and it clarifies that this server does not upload bundles, so they must be uploaded from CI or the Play Console first. This clearly indicates when to use this tool and what prerequisites exist.

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 read-only behavior ('read-only here'), pagination defaults (10 default, 100 max), and the structure of returned entries. It does not mention potential errors or auth requirements, but for a read-only list operation this is reasonably transparent.

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

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

The description is a single dense paragraph that front-loads the core action and then provides necessary details (pagination, read-only nature, sibling reference). All sentences contribute useful information, though it could be slightly more concise by splitting into a few short sentences. Still highly 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?

For a list tool with 3 parameters and no output schema, this description is quite complete. It covers the purpose, default behavior, pagination, and how to handle the nextPageToken. It also tells the user where the full definition lives. It lacks explicit mention of response format details beyond the entry fields, but that is arguably covered by the entry description.

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%, but the description adds valuable semantics beyond the schema: it specifies the default limit value, explains the purpose of page_token ('nextPageToken from a previous call'), and notes that package_name defaults to GOOGLE_PLAY_PACKAGE_NAME. This enriches the schema without redundancy.

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 explicitly states the action (list) and resource (device tier configs of an app), with a clear ordering clause ('newest first') and a one-sentence definition of what a device tier config is. It also distinguishes from the sibling get_device_tier_config by noting that this lists summaries while the get tool returns full definitions.

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 explicit usage context: when you need the full definition, use get_device_tier_config; creation is done elsewhere (Play Console or bundletool). It also explains pagination usage with page_token from nextPageToken, which directly guides invocation.

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 tool lists APKs (a read operation) and includes download ids, which implies a read-only behavior. However, it doesn't mention any potential side effects, authentication requirements, or rate limits. Since it's a listing operation, the lack of explicit read-only declaration is a minor gap, but the description is adequate for a simple read tool.

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

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

The description is a single, well-structured sentence that front-loads the purpose and includes a helpful pointer to list_bundles. No wasted words, and it's appropriately concise 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 tool's simplicity (2 params, no output schema, no nested objects), the description is complete enough. It covers what the tool does, the key parameter (version_code), and how to obtain it. The only minor gap is not explicitly stating the return format, but since there's no output schema, the description could have mentioned that it returns a list of APKs with download ids, which it does. Overall, it's sufficient for an agent to use 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 the schema already documents both parameters. The description adds context by mentioning 'version code' and referencing list_bundles, but it doesn't add new meaning beyond the schema. Baseline 3 is appropriate 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?

The description clearly states the tool lists APKs generated by Google Play from an uploaded bundle for a given version code, and specifies the grouping (by signing key) and types (split, standalone, universal) with download ids. It distinguishes from sibling list_apks by focusing on generated APKs from bundles, and explicitly references list_bundles for finding version codes.

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: use this tool to list generated APKs for a version code, and explicitly directs to list_bundles to find version codes. It doesn't explicitly state when not to use it or mention alternatives like list_apks, but the context is clear enough 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?

With no annotations provided, the description must disclose behavioral traits. It does mention it returns ids, urls, and hashes, and scopes to one type/locale, but it does not explicitly state that it is read-only, any required permissions, or whether pagination applies. The verb 'List' implies a read operation, but without annotation confirmation or further details, this is only minimal 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 exactly two sentences: the first states the purpose and output, the second provides a usage pointer. There is no redundant or filler content. It is front-loaded with the core action and immediately mentions the return fields, making it efficient and 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?

For a simple list operation with high schema coverage and no output schema, the description provides sufficient context. It tells the agent what the tool returns, the scoping dimensions (type and locale), and how the result should be used (with delete_listing_image). No additional details are needed for an agent to invoke it correctly.

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

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

The schema covers all three parameters with 100% description coverage, so the description adds no new parameter-level information. It does not elaborate on how parameters interact or provide usage notes beyond what the schema already explains. Thus, a baseline score of 3 is appropriate 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?

The description clearly states the verb (List), the resource (store images), and the scope (one type for one locale). It also specifies the output fields (id, url, sha1, sha256), which distinguishes it from sibling tools like list_listings that cover listing metadata. This is a specific, non-tautological 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 gives explicit usage guidance by stating 'Use the returned ids with delete_listing_image,' which indicates a primary follow-up action. It also implicitly conveys the tool is for listing images of a specific type and locale. However, it does not explicitly state when not to use it or provide alternatives beyond the delete tool, so it falls short of a perfect 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?

With no annotations, the description carries the burden. It discloses the return fields and implies a read-only listing operation. It doesn't cover error cases or pagination, but for a simple list tool, it provides sufficient behavioral context.

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

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

Two sentences: the first is action-oriented naming the resource and return fields, the second gives workflow guidance. No unnecessary 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 a single optional parameter and no output schema, the description covers the tool's purpose, scope, and return content adequately. It could mention pagination or error behavior, but these are not critical for a simple listing 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 fully describes the only parameter (package_name) with an example and default behavior, so the description doesn't need to add parameter details. Baseline 3 applies as schema coverage is 100%.

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 lists every localized store listing for an app, specifying the exact fields returned (language, title, shortDescription, fullDescription, video). It also distinguishes from sibling tools by positioning this as the starting point before updating listings.

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 'Start here' and 'before using update_listing', providing clear temporal guidance on when to use this tool. It doesn't mention alternatives or exclusions, but the workflow context is strong enough for a 4.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, and it largely delivers by revealing the domain stakes ('push a remote in-app update to users stuck on a broken release') and surfacing the complete status enum. It stops short of disclosing list behavior such as empty results for no matching version, pagination, result ordering, or error handling, which would push it to a 5. The 'List' semantics are consistent with a read operation, so there's no contradiction with the absence of annotations. Importantly, the description doesn't just describe the tool's behavior — it reveals the underlying purpose of the resource it manages, which is valuable context for the agent.

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

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

Two sentences totaling roughly 70 words deliver purpose, return fields, status enums, domain context, and sibling-workflow guidance with zero fluff. The structure front-loads the verb+object in the first four words, and each sentence earns its place.

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

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

For a tool with no output schema and no annotations, the description covers all essential ground: what it returns (statuses, timestamps, targeting), why it exists (recovering users on broken releases), and the prerequisite steps (confirm crash rates/errors first). Given the low complexity (2 params, simple list operation), the description is complete for an agent to select and correctly use the tool. The 100% schema coverage further fills any remaining gaps.

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

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

Schema coverage is 100% (both package_name and version_code have rich type descriptions), so the baseline is 3. The description's 'targeting a version code' merely reinforces what the schema already explains about version_code. No parameter-enriching semantics are added beyond what the schema provides, and none are strictly needed given the schema's clarity.

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

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

The description uses a specific verb ('List') with a clear resource and scope: 'the app recovery actions targeting a version code,' and enumerates the return fields (appRecoveryId, status, targeting, timestamps). The status enum (DRAFT, ACTIVE, CANCELED, GENERATION_IN_PROGRESS, GENERATION_FAILED) adds precision that differentiates it from sibling listing tools like list_releases. This is a specific verb+resource+scope construction that clearly distinguishes the tool's 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 explicitly guides when to use this tool: 'use query_crash_rate and search_error_issues first to confirm which version is broken,' naming two concrete alternative tools and establishing the workflow ordering. The implication is clear — this tool is for after the broken version is confirmed. This is exactly the kind of explicit when/when-not/alternatives guidance the rubric rewards.

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 full transparency burden. It discloses read-only behavior ('reads the track directly'), exclusion of obsolete releases, max 20 results, and the lifecycle state values. This significantly informs the agent of side-effect-free and scoped behavior.

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

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

Two dense sentences front-load the purpose, then pack essential behavioral details, lifecycle states, and alternatives. Every sentence provides unique value without redundancy.

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

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

Despite no output schema, the description fully specifies return fields (releaseName, track, activeArtifacts, releaseLifecycleState) and all possible states. It also covers limitations (max 20, excludes obsolete) and the read-only nature, making it complete for a list tool.

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

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

Schema coverage is 100% with descriptive parameter meanings. The description adds no parameter-specific details beyond schema, so baseline of 3 is appropriate. The high-level context about output fields doesn't enhance parameter understanding further.

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 lists releases on a track, including non-live ones, and specifies the entry fields. It distinguishes itself from get_track by noting it uniquely shows review state, making its purpose unambiguous and differentiated 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?

Explicitly tells when to use this tool: 'use it to check whether a submitted release is still being reviewed' and contrasts with get_track for rollout details. Naming the alternative directly provides clear decision 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, the description carries full responsibility. It discloses ordering, the exact structure of returned reviews (reviewId, authorName, comments[] with detailed fields), and significant API limitations. It also indicates that reviewId can be used with other tools, adding valuable behavioral context.

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

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

The description is compact yet information-dense, with two sentences covering purpose, return structure, API constraints, and integration with sibling tools. Every sentence earns its place and key information is front-loaded.

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

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

Given the absence of an output schema, the description thoroughly explains the expected review structure and fields, as well as API limitations. This is particularly important for a list operation and makes the tool behavior fully understood.

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

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

The input schema already documents all three parameters (limit, package_name, translation_language) with clear descriptions, achieving 100% schema coverage. The tool description does not add parameter-specific information beyond the schema, so it meets the baseline per calibration guidelines.

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 lists recent user reviews for an app and orders them newest first. It also references reviewId for downstream tools like get_review and reply_to_review, distinguishing it from sibling tools such as list_tracks.

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 concrete usage context by noting the Google Play API only returns reviews from the last 7 days, only those with written text, and only for production releases. This helps an agent decide when the tool is appropriate, though it doesn't explicitly contrast with alternatives beyond downstream references.

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 detailes the returned fields and statuses (draft/inProgress/halted/completed), giving useful context on what the tool reveals. It doesn't mention pagination or rate limits, but for a read-only listing tool, this level of detail is sufficient.

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 purpose, followed by details and usage guidance. Every clause adds value without redundancy. The structure is highly 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?

For a simple list tool with one parameter and no output schema, the description is complete: it states the resource, the exact data returned, the statuses, and the recommended usage order. It fully compensates for the lack of an output schema by enumerating the fields.

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

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

The input schema already documents parameter package_name with a clear description and a default value. Schema description coverage is 100%, so the description doesn't need to add param details. The description adds no extra parameter semantics beyond what the schema provides, 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 clearly states 'List all release tracks for an app' with specific details on track types (internal, alpha, beta, production, custom closed) and the release data returned (name, versionCodes, status, userFraction, releaseNotes). This explicitly distinguishes it from sibling tools like get_track, which fetches a single track, and promote_release/update_rollout/halt_rollout, which are mutations.

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 'Start here to see what is live before using promote_release, update_rollout or halt_rollout' provides explicit guidance on when to use this tool and names the alternative tools it precedes. This is a clear usage directive, even though it doesn't contrast with get_track explicitly.

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

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

The description discloses key side effects: 'This replaces the destination track's release list' and explains rollout statuses ('completed'/'inProgress'). It also clarifies the effect of validate_only, ensuring the agent understands the operation is destructive and verifiable. Since no annotations are present, this additional detail is valuable.

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-loads the primary action, and contains no fluff. Every clause adds information: version codes, user_fraction semantics, the replacement behavior, and the validation tip are all high-value.

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

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

For a tool with 10 parameters and nested objects, the description covers the crucial decisions (full vs staged rollout, validate_only) and the core destructive nature. It doesn't enumerate every parameter (schema does that), but it creates a coherent mental model. Missing details like error handling or rate limits are minor given the schema's 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 the schema already covers 100% of parameters with descriptions, the tool description adds meaningful inter-parameter logic, such as the relationship between user_fraction and rollout status, and the default behavior for release_name and release_notes. This goes beyond a simple restatement of schema fields.

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 what the tool does: 'Promote the active release of one track to another' with a concrete example 'beta -> production' and notes it keeps version codes. This is a specific verb-resource pair with scope, effectively distinguishing it from siblings like update_rollout or halt_rollout.

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 explains when to use full rollout (omit user_fraction) vs staged rollout (pass user_fraction) and advises using validate_only first. While it doesn't explicitly contrast with alternative tools like update_rollout, the context of 'matching how promoting works in the Play Console' gives practical 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, the description carries the burden. It discloses daily aggregation in America/Los_Angeles and a ~1 day lag, which is useful behavioral context. However, it does not state that the operation is read-only or mention any rate limits or error conditions. Given that it is a query tool, these details are useful but not critical.

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

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

The description is two sentences, front-loaded with the core purpose. Every sentence adds value: the first states the query and optional breakdowns, the second covers aggregation and lag. 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 8 parameters and no output schema, the description covers the essential behavior: what metrics, the aggregation period and location, and data lag. It does not describe the return format, but for a query tool that is often implied. It is complete enough for an agent to understand what it does and when to use it.

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

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

Schema coverage is 100%, so parameters are already well-documented. The description adds minimal extra meaning beyond naming the default metrics and some example dimensions, which is redundant with the schema. It does not provide syntax or format details beyond what the schema has.

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

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

The description clearly states it queries ANR rate from Android vitals, specifically naming the metrics anrRate and userPerceivedAnrRate, and it distinguishes from sibling tools like query_crash_rate by focusing on ANR. This meets the standard of a specific verb+resource with clear scope.

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

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

The description explains the optional breakdowns (by version code, device model, country) and mentions data aggregation but does not explicitly state when to use this tool versus alternatives. There is no 'use when' or 'instead of' guidance, though the context of sibling tools implies it is for ANR metrics.

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 behavioral disclosure. It clearly notes the daily aggregation restriction, which is a significant behavioral trait. It also hints at metrics/dimensions support beyond the schema. It does not mention permissions or side effects, but for a query tool, read-only behavior is implicit; the daily-only disclosure is the key trait.

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

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

The description is two sentences, front-loaded with the core metrics, and every sentence adds value: it lists metrics, additional options, a use-case hint, and the aggregation constraint. No fluff or redundancy.

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

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

Given the tool is a focused query operation with 8 parameters but no output schema, the description provides necessary context: what it returns (percentiles), common use case (memory pressure) with a sibling tool, and a key limitation (daily only). It could mention default row limits or return structure, but the core information for selection and invocation is present.

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 like dates are well-documented. The description adds value by naming available metrics (P75/P95) beyond the schema's generic 'Metrics to fetch' and highlighting special dimensions (processName, appState) that are also in the enum. This adds meaning beyond simple property names.

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 immediately states it queries bitmap memory usage percentiles and lists exact metrics (bitmapMemoryUsageP50/P90/P99 plus distinctUsers). It also clarifies additional supported metrics (P75/P95) and dimensions (processName, appState), distinguishing this query from sibling tools like query_lmk_rate.

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

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

It explicitly says 'Pair with query_lmk_rate when investigating memory pressure', giving a clear when-to-use and a complementary tool. It also states 'Daily aggregation only', setting expectations about data granularity. It does not explicitly list when NOT to use it, but the provided guidance is strong.

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 full burden. It discloses key behavioral traits: daily aggregation in America/Los_Angeles, ~1-day data lag, and omission of slices with too few users. It does not explicitly state read-only behavior, but that is implied for a query tool. The disclosed traits add value beyond 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 with zero fluff. It front-loads the core purpose, lists metrics, notes optional dimensions, and adds crucial data freshness/aggregation context. 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 no output schema and a moderately complex query tool (8 params, 2 required), the description covers the essential context: what metrics are fetched, how data is aggregated and delayed, and that dimensions are optional. It sufficiently prepares an agent to use the tool without ambiguity.

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

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

Schema coverage is 100% with descriptions for all 8 parameters, so baseline is 3. The description adds meaning by explaining the two default metrics (crashRate and userPerceivedCrashRate) and their definitions, which the schema does not. It also clarifies that dimensions are optional, reinforcing the schema's examples. This is a modest but meaningful addition.

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

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

The description clearly identifies the tool as querying crash rate metrics (crashRate and userPerceivedCrashRate) from Android Vitals, distinguishing it from sibling tools like query_anr_rate and query_slow_start_rate which target different metrics. The verb+resource structure is specific and unambiguous.

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

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

The description implies usage for crash-rate queries and mentions optional breakdowns (version code, device model, country), but does not explicitly name alternatives or state when not to use this tool. Since sibling tools are clearly for different metrics, the context is inferrable but not overt.

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?

Since no annotations are provided, the description carries full burden. It states the query returns rows always broken down by reportType (API requirement) and suggests adding issueId. However, it does not explicitly confirm it is a read-only operation or describe any side effects or limitations (e.g., no filtering by user). The read-only nature is implied but not stated, so score is moderate.

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

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

The description is two sentences, front-loaded with the purpose, then adds usage guidance. No fluff or repetitive details. Every sentence delivers necessary information efficiently.

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

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

The description covers the tool's purpose, mandatory reportType breakdown, and a workflow for issue-level analysis. It does not describe the output structure (since there is no output schema), but it does clarify that rows are returned. Given the tool has 8 parameters and no annotations, the description is fairly complete, though it could mention the aggregation_period or pagination, but those are covered by the schema. Overall, adequate for a query 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 descriptions cover all parameters (100% coverage), so baseline is 3. The description adds value by explaining that reportType is always a dimension (mandatory) and how to use issueId to see issue-level volume, which goes beyond what the schema states. It also ties into the workflow with search_error_issues, enhancing parameter 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 tool queries absolute counts of error reports (crashes/ANRs) with specific metrics (errorReportCount, distinctUsers) over time. It distinguishes itself from sibling rate queries (e.g., query_crash_rate) by emphasizing absolute counts, and explicitly mentions the mandatory reportType breakdown, making it distinct.

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

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

Provides clear guidance on how to get issue-level detail (add issueId) and directs to search_error_issues for details. It implies use when absolute counts are needed versus rate tools, but does not explicitly contrast with sibling rate queries or state when not to use it. Still effective workflow 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, the description carries the behavioral disclosure. It explains the metric definition, the daily aggregation limitation, and how to request rolling averages via specific metrics. This goes beyond the schema, though it repeats the DAILY enum and doesn't mention pagination or output format. The added context on metric interpretation compensates for missing 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?

The description is a tight two-sentence paragraph, front-loaded with the primary purpose, then adding metric context and aggregation guidance. No filler or redundant detail, 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?

Despite having 8 parameters and no output schema, the description adequately covers the metric's meaning, the rolling-average option, and the daily constraint. It does not explain the return format, but for a query tool with a clear metric definition, this is sufficient. The schema covers parameter details, so the description's role is to provide metric-specific context, which it does.

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

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

Schema covers 100% of parameters, so baseline is 3. The description adds value by explaining the default metrics (excessiveWakeupRate and distinctUsers), how to override them with rolling average metrics, and confirms the daily-only aggregation. This enriches the 'metrics' and 'aggregation_period' parameters beyond their schema descriptions.

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

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

The description clearly states the tool queries the excessive wakeup rate metric, defines it, and distinguishes it from sibling metrics by specifying it's a battery-drain metric. The verb 'Query' and resource 'excessive wakeup rate' are explicit, and the context about background work separates it from other Vitals queries.

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 usage context by explaining the metric is battery-drain related and counts background users, but does not explicitly state when to choose this tool over alternatives like query_stuck_wakelock_rate or when-not to use it. No exclusion criteria or alternative tool names are given.

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 transparency burden. It explains the metric's meaning, its user-perceived scope, the inclusion of distinctUsers, daily-only aggregation, and how rolling averages can be requested. It does not cover potential response shape or permissions, but for a query tool this is reasonable context.

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

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

The description is three sentences long, front-loaded with the primary purpose, and every sentence provides useful information: metric definition, sibling-tool relationship, and aggregation guidance. No filler or redundancy.

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

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

For an 8-parameter query tool with no output schema and no annotations, the description covers the essential context: metric semantics, related tools, aggregation constraints, and rolling-average options. It could mention pagination or response structure, but the schema already documents parameters well and the description compensates where it matters most.

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 genuine value by naming the default metrics (userPerceivedLmkRate, distinctUsers), suggesting valid metric values for rolling averages, and reinforcing that aggregation_period only supports DAILY. This goes beyond the schema's generic array descriptions.

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

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

The description opens with a specific verb and resource: 'Query the low-memory-kill rate' and precisely defines the core metric userPerceivedLmkRate. It clearly distinguishes this tool from sibling stability tools by contrasting LMK with crash and ANR metrics.

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: read it alongside query_crash_rate and query_anr_rate because LMK is a stability failure that is not reported as a crash. It also gives concrete guidance about requesting rolling average metrics, though it does not explicitly enumerate when not to use the tool.

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

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

With no annotations provided, the description carries the full burden, and it delivers key behavioral context: RSS plus swap definition, the Android Vitals mapping, default P50/P90/P99 metrics, optional P75/P95 support, available dimensions, and daily-only granularity. It does not cover error/rate-limit behavior, but for a query tool the disclosed constraints are substantial and non-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?

Three focused sentences deliver the tool's purpose, metric units, additional options, sibling distinction, and a critical constraint. No filler or repetition of schema details.

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

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

Given the schema already documents all 8 parameters, the description supplies the missing domain context: what the metric measures, why it matches Android Vitals, what additional aggregations/dimensions exist, the daily-only restriction, and the relevant sibling tool. This is complete for a query tool without an output schema.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value beyond the schema by explaining the metric set, clarifying that P75/P95 are available via the metrics parameter, naming the processName and appState dimensions, and reinforcing the DAILY-only aggregation restriction.

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 ('Query'), a specific resource ('overall app memory usage percentiles'), and concrete metric names with units. It clearly distinguishes this from sibling query_bitmap_memory_usage by explaining what this tool covers and what the sibling covers.

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 daily-only aggregation constraint and gives a direct alternative: 'Use query_bitmap_memory_usage to see how much of it is bitmaps.' This gives the agent clear when-to-use and when-to-choose-a-sibling 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, the description carries the full transparency burden. It discloses that non-game apps produce errors or empty rows and explains the metric semantics. However, it does not explicitly state that the operation is read-only or describe any potential side effects, though the query nature implies it.

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 yet information-dense, comprising two sentences that convey the core purpose, key metrics, usage restrictions, and parameter nuances. It avoids redundancy and stays focused.

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 essential context: what the tool does, when to use it (games only), metric definitions, rolling average variants, and aggregation period. It does not describe the output format, but given the query nature and sibling tools, this is acceptable. The description is sufficiently complete for a user to decide when and how to invoke it.

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

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

The description adds value beyond the schema by explaining the meaning of the metrics (share of users missing frame rate thresholds) and clarifying the aggregation period limitation (only DAILY). It also hints at the need to request weighted variants in the metrics parameter, which the schema does not explicitly cover.

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: querying slow rendering rate metrics for games. It explicitly names the metrics (slowRenderingRate20Fps, slowRenderingRate30Fps) and provides a precise definition, distinguishing it from sibling query tools.

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

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

The description gives explicit usage instructions: it is for games only and warns that other apps will yield errors or empty rows. It also advises using *7dUserWeighted / *28dUserWeighted variants for rolling averages and notes that only daily aggregation is supported, guiding the user on correct parameter usage.

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 and does disclose meaningful behavior: forced startType grouping, daily-only aggregation, and metric aliases for user-weighted rolling averages. It doesn't cover every possible response edge case, but the key constraints that affect query results are transparently stated.

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 action and resource, and every sentence adds meaningful detail. No filler or repetition of schema content.

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

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

For a query tool with 8 parameters and no output schema, the description handles core domain nuances: metric definitions, forced dimension, API requirements, and aggregation constraints. It gives enough of the row shape via 'slowStartRate plus distinctUsers' and the startType breakdown, though a bit more about response format would push it higher.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value beyond schema by detailing valid metric values (slowStartRate7dUserWeighted, slowStartRate28dUserWeighted) and explaining why startType is a required dimension. This enriches understanding of the metrics and dimensions parameters.

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

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

The description clearly states the tool's purpose: 'Query how often the app started slowly' and specifies the exact metrics returned (slowStartRate, distinctUsers). It distinguishes itself from sibling vitals tools by naming the specific metric and the forced startType breakdown.

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 actionable usage context: rows are always broken down by startType, the API requires this due to differing thresholds, and users should request slowStartRate7dUserWeighted or slowStartRate28dUserWeighted to match Play Console rolling averages. It does not explicitly name alternatives, but the guidance is clear and specific.

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 transparency burden. It discloses the metric formula, the denominator ('users doing any work on the device'), that distinctUsers is included by default, and the daily-only aggregation constraint. It does not describe response shape, but it provides meaningful behavioral context beyond what structured fields would show.

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

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

The description is four short sentences with the core purpose front-loaded. Each sentence provides useful information—metric definition, denominator, rolling-average options, and aggregation constraint. The phrase 'Another battery-drain metric' is mildly redundant but not wasteful enough to lower the score further.

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

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

For a tool with no output schema, no annotations, and 8 parameters, the description covers the essential semantic context: what the metric means, its user denominator, default companion metric, rolling-average alternatives, and aggregation limitation. It does not explain return-value structure or compare with sibling tools, but it is largely complete for invocation purposes.

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 for parameters is 100%, so the baseline is 3, but the description adds real value by naming valid metric values (stuckBgWakelockRate7dUserWeighted and stuckBgWakelockRate28dUserWeighted) and explicitly stating that only DAILY aggregation is supported. This goes beyond the schema's generic 'Metrics to fetch' 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 opens with a specific verb and resource: 'Query the stuck background wakelock rate' and then precisely defines the metric as stuckBgWakelockRate (share of distinct users holding a PowerManager wakelock in the background over one hour). It clearly identifies the metric's identity, though it does not explicitly contrast it with sibling battery-drain tools like query_excessive_wakeup_rate.

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

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

The description gives operational guidance: use stuckBgWakelockRate7dUserWeighted or stuckBgWakelockRate28dUserWeighted for rolling averages, and use DAILY aggregation only. However, it does not explicitly state when to choose this tool over sibling metrics such as query_excessive_wakeup_rate or query_slow_rendering_rate, so the use-case guidance is implied rather than explicit.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It covers key traits: replies are public, limited to 350 characters, editing existing replies, and user notification only for the first reply. This goes well beyond a basic 'reply to a review' and helps the agent anticipate side effects.

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

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

The description is three sentences, each adding essential information: purpose, constraints, and behavioral nuance. It is front-loaded, with no wasted words, making it easy for an agent to parse quickly.

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

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

For a simple tool with 3 parameters and no output schema, the description is fully sufficient. It explains the action, input source, limitations, and side effects, covering all necessary context for selection and invocation. Additional details like return values are not needed given the tool's simplicity.

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

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

Schema coverage is 100%, so parameters are already well-documented with descriptions for review_id, reply_text, and package_name. The description adds little beyond what the schema states—'Get review IDs from list_reviews' mirrors the schema's own description, and the character limit is already in the schema. Thus, 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 opening phrase 'Post a public developer reply to a user review' uses a specific verb and resource, making the tool's purpose unmistakable. It is clearly distinct from sibling tools like list_reviews or promote_release, which serve different functions.

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 advises to obtain review IDs from list_reviews, providing a clear workflow hint. It does not explicitly state when not to use the tool or mention alternatives, but the tool's narrow purpose and the instruction to use list_reviews for IDs imply appropriate usage context.

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

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

With no annotations, the description carries the burden and adds meaningful behavioral context: it explains issues are grouped/deduplicated, describes the key fields (errorReportCount, distinctUsers, affected versions, issueUri), and provides a pointer to the sibling for deeper detail. It omits potential edge cases like pagination or error behavior, but the read-only search nature is clear.

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 zero redundancy. The first sentence defines the tool, the second adds valuable output context and a workflow hint. Perfectly sized.

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 there is no output schema, the description compensates well by enumerating the response fields and linking to the sibling tool for drill-down. It covers the essential context for an agent to select and use the tool effectively, with minor gaps around default filter behavior not being mentioned.

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 does not add parameter-level details beyond what the schema already provides; it focuses on the output structure and sibling usage, which is acceptable but not additive.

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 distinct resource ('grouped crash/ANR issues for an app'), explicitly explaining the deduplication semantics. It clearly distinguishes from the sibling tool `search_error_reports` by describing the aggregation layer and how it relates to individual reports.

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 clear workflow: use this tool to find issues, then use `search_error_reports` with the issue name to read stack traces. This names an alternative tool and gives an example of when to use it, though it does not cover all sibling comparisons (e.g., `query_crash_rate`).

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 results include reportText with stack trace, device info, and app version, which is useful behavioral context. It doesn't mention rate limits or failure modes, but the read-only nature of 'search' is implicit.

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. Front-loaded with the core purpose, then adds a critical usage detail. 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?

With no output schema, the description explains what's inside the reports. It covers filter usage and references sibling tools, but could mention result count or paging behavior explicitly. Overall, it's sufficient for an agent to select and 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 has 100% parameter description coverage, giving a baseline of 3. The description adds a concrete filter example and references the issue name source, going beyond the schema's generic example.

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 'Search individual crash/ANR error reports for an app' with a specific verb and resource. It distinguishes itself from the sibling tool 'search_error_issues' by focusing on individual reports and referencing the sibling for issue names.

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

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

Provides explicit guidance on filtering to one issue using an issue name from search_error_issues, offering a concrete filter example. This clarifies when to use this tool and how it relates to the sibling.

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 behavioral transparency burden. It does disclose partial updates and the validate_only dry-run pattern, which is valuable. However, it omits potential side effects such as whether changes are sent for review, whether approvals are needed, or what happens to existing values not passed.

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

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

The description is three short sentences with no filler. The first sentence states purpose, the second clarifies update semantics, and the third gives a practical usage tip—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 the rich 100%-covered schema and clear behavioral guidance, the description is largely complete for an update tool. It lacks only a mention of broader consequences like review flow or return behavior, but these are reasonable gaps for a concise description.

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 meaningful parameter-related context by stating that only passed fields are changed and by recommending validate_only usage, which enriches the schema's per-field descriptions without repeating them.

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

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

The description clearly states the tool updates app-level contact details and default language, which is precise and distinguishes it from sibling tools like update_listing or update_release_notes. The resource and scope are explicit, leaving no ambiguity about what is being changed.

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 instruction to 'Use validate_only first to check the change without committing' provides concrete guidance for safe usage. It also sets partial-update expectations with 'Only the fields you pass are changed,' but it does not explicitly contrast with sibling tools or mention when to prefer update_app_details over update_listing.

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 and discloses key behaviors: partial updates (only passed fields change), automatic creation for missing locales, Google's character limits, and the validate_only dry-run option. It does not cover review-skipping behavior or auth/rate limits, but covers the essential operational traits.

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?

Five short, information-dense sentences front-load the purpose and then add behavioral details, limits, and a usage tip. No filler or redundancy.

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

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

For an 8-parameter tool with no output schema, the description covers purpose, update semantics, creation, limits, and validation flow. It omits some details like changes_not_sent_for_review semantics, but the schema covers those. Overall, it's complete enough for effective selection and invocation.

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

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

Schema coverage is 100%, so baseline is 3. The description adds meaningful context about partial updates (only passed fields are changed) and reiterates character limits, which clarifies how parameters interact. However, individual parameter descriptions already exist in the schema, so added value is moderate.

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

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

The description states the tool updates store listing text for one locale, explicitly differentiating from read-only siblings like list_listings and get_listing. It also clarifies partial update scope and creation-if-missing behavior, making the 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 provides clear context for when to use (updating listing text) and a specific best practice to use validate_only first. It does not explicitly name alternatives like update_app_details, but the 'one locale' and 'listing text' framing implies the scope. Thus clear context, but no explicit exclusions.

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

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

With no annotations provided, the description correctly bears the full burden of disclosure. It adds the valuable constraint 'Notes are capped at 500 characters per locale by Google' and clarifies the mutation targets the active release only. Could go further by noting failure behavior or review implications, but this meaningfully exceeds baseline 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?

Three sentences, each earning its place: purpose/scope, prerequisite workflow, and hard constraint. Front-loaded with the action verb, zero filler, and no repetition of schema content.

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

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

For a mutation tool with no annotations and no output schema, the description covers the essentials: operation semantics, exclusion scope, a prerequisite call, and a hard constraint. It could note reversibility or review implications given the 'replace' semantics, but given the surrounding schema already warns about full-set replacement, what's present independently conditions the agent well.

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

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

With 100% schema coverage, the baseline is 3; the description pushes beyond by warning of the 500-character limit on text (a constraint absent from the schema) and directing the agent to get_track to discover valid locale values. This meaningfully enriches the release_notes parameters without redundancy.

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?

Uses a specific verb ('Replace') with a precisely scoped resource ('localized release notes of the active release on a track') and explicitly distinguishes what it does NOT touch ('version codes, status and rollout fraction'), differentiating it from siblings like update_rollout and promote_release. The 'what's new' clarification disambiguates the Google Play terminology.

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 the agent to 'Use get_track first to see the current notes and which locales exist,' naming a specific sibling as a prerequisite. It lacks an explicit when-not-to-use statement contrasting with non-sibling alternatives, but the 'leaving...untouched' phrasing implicitly scopes its purpose against sibling tools like update_rollout.

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 transparency burden. It discloses two key behavioral traits: passing 1 completes the rollout and changes status to 'completed', and updating a halted release resumes it. These go beyond the raw schema. However, it does not mention what happens on validation failure, rate limits, or whether package_name can be omitted, leaving some 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?

Three short sentences, each earning its place: the core action, the special value behavior, and a prerequisite tip. No filler or redundancy. The verb and resource are front-loaded in the first sentence.

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

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

For a mutation tool with 5 params and no output schema, the description covers the essential state transitions and the prerequisite to read current fraction. It lacks details on the response or what happens if the track is not in an updatable state, but the schema fills parameter gaps. Overall, it is reasonably complete for the tool's moderate complexity.

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

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

Schema description coverage is 100%, so the schema already explains every parameter. The description adds no new parameter-level semantics beyond repeating that user_fraction=1 completes the rollout, which the schema also states. It does not clarify validate_only or changes_not_sent_for_review further, but the schema descriptions are sufficient.

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 'Change the staged rollout percentage of the in-progress release on a track' – a specific verb ('Change') and resource (staged rollout percentage on a track) that clearly differentiates from siblings like halt_rollout or promote_release. It also explains the completion and resume behavior, reinforcing its unique role.

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

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

It gives explicit actionable guidance: 'Use get_track to see the current userFraction first.' This tells the agent the prerequisite step. It also implies usage on in-progress releases and clarifies special cases (complete rollout, resume halted release), but it does not explicitly state when not to use it or compare with alternatives like halt_rollout or promote_release.

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

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

The description transparently notes that the operation replaces the entire list of Google Groups, warning users to include every group they want to keep. It does not mention potential side effects like required permissions or reversibility, but the core behavior is clearly disclosed.

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, using only two sentences to convey the action, the replacement semantics, and the prerequisite. No redundant or vague language is present.

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

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

The description provides sufficient context for the operation: what it does, the prerequisite (get_testers), the scope (closed tracks), and the caution about replacing the list. Since there is no output schema, explaining return values is unnecessary. The description covers the essential behavioral nuances fully.

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

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

The input schema provides descriptions for all 5 parameters, and the tool description adds meaningful context—for instance, explaining that google_groups is a full replacement and reinforcing the track parameter's scope. No parameter is left ambiguous.

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 ('Set the Google Groups that have access to a closed testing track') and scopes it to closed tracks, distinguishing it from other tools like get_testers and update_rollout.

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 to call get_testers first to obtain the current list, and it specifies that the tool only applies to closed tracks (alpha and custom tracks), providing clear when-to-use and when-not-to-use guidance.

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