ShipASO

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

Annotations already carry readOnlyHint and openWorldHint, and the description reinforces them by saying 'never edits or pushes' while adding that data comes from the 'live public listing.' It also discloses the output shape (severity + impact, summary), which is useful beyond the annotations.

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

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

Two tight sentences; purpose, output, source, and safety are all front-loaded. The repetition of 'read-only' is minor and reinforces the no-mutation guarantee.

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 lack of an output schema means the description's mention of findings and summary is helpful, and the parameter and read-only story is complete. But it omits explicit platform/storefront scope, which is important given the sibling audit_play_app, and offers no behavior on edge cases like failed resolution.

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

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

Schema description coverage is 100%, with meaningful descriptions for query, country, and bundleId. The description adds no parameter-level meaning, so it stays at the baseline 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 names a concrete operation ('listing audit') and the deliverable ('prioritized findings ... plus a summary'), and explicitly marks it read-only. However, it calls the target a generic 'listing' and doesn't distinguish this tool from the sibling audit_play_app, so an agent may confuse the two storefronts.

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 read-only framing implies it is for inspection rather than modification, but there is no explicit when-to-use guidance or mention of alternatives such as audit_play_app or propose_copy. The 'never edits or pushes' note gives context but not clear selection criteria.

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

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

Annotations already carry readOnlyHint=true and openWorldHint=true, and the description does not contradict them. It adds genuine value beyond those hints: capability locks for owner-only surfaces, the platform fact that Play has no keyword field, the judging standards (30/80/4000), and the keyword-stuffing guard. It stops short of 5 because it does not disclose error behavior, rate limits, or how invalid package ids are handled.

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

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

All core components are front-loaded in the first sentence, followed by input-format guardrails, a platform constraint, and a safety statement. Every clause earns its place; nothing repeats what the schema or annotations already state.

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

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

This is a complex 5-parameter audit with no output schema, so the description bears the return-format burden. It gives a high-level output map (screenshot grade, prioritized findings + summary) and covers safety, input format, and platform constraints. The concrete response shape and error behavior remain unspecified, which would matter for an agent parsing the result.

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

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

Schema coverage is 100%, so the baseline is 3 with the schema carrying the load. The description adds one meaningful exclusion — 'NOT a free-text name (Play has no public name search)' — which goes beyond the schema's 'package id or URL' wording and prevents a common invocation error, and it ties brand/targets to their audit purposes.

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

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

States a specific verb+resource: audit a Google Play listing, then enumerates exactly what the audit covers (screenshot grade, 30/80/4000 budgets, long-description keyword coverage, keyword-stuffing guard, prioritized findings + summary). The 'Read-only' framing plus 'capability locks for surfaces a public read can't see' separates it from sibling audit_play_app_owner, and the component list distinguishes it from narrower siblings like screenshot_coverage and keyword_gaps.

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

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

Gives explicit input constraints: accepts a Play package id (com.foo.bar) or a play.google.com URL, and explicitly excludes free-text names with a reason (Play has no public name search). 'Reads public Play data only' and 'never edits or pushes' imply when to choose this public-read tool versus an owner-level audit, though it never names sibling tools or states explicit when-to-use/when-not-to-use conditions.

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

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

Annotations already declare readOnlyHint and openWorldHint, and the description meaningfully adds to them: it opens and discards a Play edit, never commits, and therefore cannot publish. This goes beyond the annotations by explaining the mechanism and safety guarantee in concrete terms.

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

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

The description is dense and front-loaded with the most important facts: read-only, own app, official API, and the competitor alternative. There is some redundancy between 'Read-only' and 'Reads only' and the never-commits clause, but each sentence still contributes safety or usage context.

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

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

The description covers the key contextual needs: prerequisites, side-effect safety, scope, and sibling routing. Since there is no output schema, describing the return shape would be helpful, but for an audit tool the output is reasonably inferable and the invocation decision is fully supported.

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

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

Schema description coverage is 100%, so every parameter is already explained in the input schema. The description does not repeat parameter details, which is fine, but it also does not add additional semantic value beyond the schema. A baseline 3 is appropriate.

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

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

The description states a specific verb and resource: a read-only audit of YOUR OWN Google Play app via the official Play Developer API. It also explicitly differentiates itself from the sibling audit_play_app by marking this as owner-only and that as competitor-oriented, so an agent can distinguish them without opening schemas.

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

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

The description gives clear usage boundaries: owner-only use, and 'for a competitor use audit_play_app' as the explicit alternative. It also states the prerequisite of a configured Play service account, which helps the agent know when it can or cannot be invoked.

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

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

Annotations already declare readOnlyHint=true, and the description reinforces this with 'Read-only' and 'Read-only metadata comparison.' It adds valuable behavioral context by stating no ranking data is invented and that it compares against the last seen state, which implies stateful persistence without explicitly detailing 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?

Two focused sentences with no wasted words. The core purpose is front-loaded as 'Read-only competitor diff,' and the clarifying sentence adds meaningful constraints 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?

With no output schema, the description supplies the essential return shape: current listings, changes versus last seen state, and a digest line. It also covers the read-only nature and scope. It doesn't detail pagination or data freshness, but for a competitor-diff tool the description is reasonably complete.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds mild context by saying competitor names are resolved, which aligns with the 'competitors' parameter, but it does not materially extend beyond the schema's parameter 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 names a specific verb ('resolves'), a resource ('named competitors'), and the tool's purpose as a read-only diff. It also differentiates itself from ranking tools by explicitly stating no ranking-algorithm data is invented, making it distinguishable from siblings like rank_check.

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

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

The description clearly conveys when to use the tool: when you need current competitor listings, changes from last seen state, and a digest line. The read-only metadata comparison phrase and the exclusion of ranking data provide context, though no explicit alternatives are named.

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

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

Annotations already mark the tool as read-only and non-destructive, and the description reinforces that with 'Read-only.' It goes beyond annotations by disclosing the data source limitation: 'Inferred from competitor name/subtitle only — never their ranking algorithm,' which is important context about what the tool genuinely knows and what it cannot reveal.

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

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

The description is two sentences, front-loads the read-only nature and core purpose, and every clause carries specific information: competitor visibility, missing targeting, top-50 ranking condition, winnability sorting, and inference limitations. There is no filler.

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

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

With no output schema, the description still tells the agent what kind of results to expect: ranked keyword gap terms with winnability ordering. Combined with complete parameter documentation and safety annotations, the context is sufficient for correct invocation, though the exact response shape and count are not specified.

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

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

Schema description coverage is 100%, so every parameter already has meaningful documentation. The tool description does not add parameter-level detail beyond what the schema provides, which meets the baseline but does not exceed it.

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

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

The description precisely defines what the tool returns: keyword opportunities based on terms competitors visibly use, that the app neither targets nor ranks top-50 for, sorted by winnability. It clearly differentiates itself from sibling tools like rank_check and competitor_watch by focusing on the visibility gap rather than direct ranking data.

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

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

The description implies the use case—find content/ASO opportunities competitors have that this app is missing—but does not explicitly state when to choose this over alternatives. It gives no exclusion criteria or sibling comparisons, leaving the routing decision partly to inference.

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

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

Description adds substantial behavior beyond the readOnlyHint: it is a static bundled heuristic, uses only already-read locales, does not fabricate live install data, and returns empty until an ASC pass exists. This directly informs agent expectations of freshness and output availability. No contradiction with annotations.

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

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

Every sentence earns its place: core purpose, data-source caveat, and empty-state behavior. The most important qualifier ('Read-only... recommendations... for one of YOUR connected apps') is front-loaded, and the whole description is compact.

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 single-parameter read tool, it covers the nature of the output (ROI-sorted locale recommendations), the data source and timing (most recent ASC run), and the empty condition. There is no output schema, but the return concept is clear enough for correct invocation.

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

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

Schema already describes appId as a connected app owned by the user with 100% coverage. The description reinforces the connection and App Store Connect scope but provides no new parameter format, constraints, or examples, 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 explicitly identifies a read-only recommendation tool for localization expansion, scoped to a connected app and latest App Store Connect run. It uses specific, distinct language ('ROI-sorted locales to add') that sets it apart from siblings like keyword_gaps and screenshot_coverage.

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

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

It gives clear context: use this only for one of the user's connected apps and only after an ASC-connected pass, with an explicit empty state before then. It does not name alternative tools or state when-not-to-use it against a sibling, so it falls just short of a 5.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true. The description adds useful behavioral context: no account needed, no store push, and the optimized copy/push commands remain behind human approval. It does not contradict annotations and provides meaningful extra behavior beyond what structured metadata conveys.

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 tightly scoped sentences lead with the core purpose, then add the most important behavioral constraints, and end with the no-key requirement. Every sentence earns its place with no repetition or filler.

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

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

The description covers the tool's scope, outputs, side effects, and authentication requirements in a compact form. Since there is no output schema, listing the snapshot contents (grade, lead rank, top-10 count, sample) helps fill that gap, though the exact meaning of 'sample' is left slightly implicit.

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 query, country, and bundleId are already well documented. The description does not add new parameter-level guidance, but it does not need to because the schema already defines accepted formats clearly. 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 opens with 'Read-only ASO snapshot of any App Store app' and lists concrete outputs (grade, lead rank, top-10 count, sample). It clearly distinguishes preview_app from mutation-oriented siblings by emphasizing it is read-only and that push actions remain behind a human-approved loop.

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

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

The description gives clear context: this is a safe, read-only snapshot that works without a key and does not push anything to the store. It implies use for quick previews rather than store modifications, though it does not explicitly name sibling alternatives such as audit_app or propose_copy as the 'when not to use' choices.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds meaningful behavioral context: the result is anonymized, aggregated, contains real rank-win numbers, excludes app names and user data, and requires no API key. This goes beyond the annotations and gives an agent confidence about privacy and access expectations.

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

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

Two sentences with no filler: the first sentence front-loads the read-only, anonymized, aggregate nature and the second provides the strategic workflow context. Every clause earns its place, and the key distinguishing traits come first.

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 parameters, no output schema, and annotations covering its read-only/open-world nature, the description is fully complete. It explains what data is returned, what is NOT returned, the authentication requirement, and the workflow purpose. An agent has everything needed to decide whether and how to call it.

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

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

The tool has zero parameters and the schema description coverage is 100%, so there are no parameter semantics to clarify. The baseline for zero-parameter tools is 4, and the description adds useful context about what the returned aggregate represents, even though no parameter details are needed.

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

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

The description clearly identifies a unique resource: read-only, anonymized aggregate proof across all tracked apps, with real rank-win numbers and no app names or user data. It positions this as the 'prove the rank moved' surface, which makes its purpose unmistakable even without an explicit verb like 'get' or 'list'. It does not explicitly name sibling alternatives, so it stops short of full differentiation.

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

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

The description implies when to use it: when you need to prove that a rank moved, closing the prepare → approve → push → prove loop. It also states it works without a key, which is a useful prerequisite clarification. However, it does not state when not to use it or point to alternatives among the sibling tools.

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

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

Annotations already mark readOnlyHint=true and openWorldHint=true, and the description reinforces and extends this by clarifying that nothing is persisted or pushed, and that publishing is human-only. This gives the agent a confident, safe interpretation of the tool's side-effect-free behavior without contradicting the annotations.

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

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

The description is front-loaded with the core purpose and uses a short, emphatic second sentence to stress the draft-only nature. It is slightly repetitive with 'DRAFT' appearing twice, but the emphasis is purposeful for preventing misuse, so it earns a strong score.

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

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

For a low-complexity tool with three optional parameters and no output schema, the description explains the return content and the critical non-persistence behavior. It does not explicitly state that at least one app identifier should be supplied, but the schema and open-world context make this reasonably inferable.

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 each parameter is already documented. The description adds the general promise that the tool works for 'any app' and includes validation, but it adds no parameter-specific meaning beyond the schema, so the baseline 3 is appropriate.

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

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

The description uses a specific verb ('Returns') with a clear resource ('a DRAFT optimized listing') and enumerates the output fields (name/subtitle/keywords/description). It also explicitly distinguishes itself from publishing by stating it does NOT push to the App Store, which separates it from any sibling publishing flow even though no sibling is named.

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

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

Provides clear context: use this to generate and read a draft proposal for any app, and explicitly states it is not for persisting or publishing. It does not name a specific alternative tool, but the exclusions are strong enough to guide an agent away from using it as a write operation.

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

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

Annotations already declare readOnlyHint and openWorldHint, and the description reinforces read-only behavior. The added claim that positions are 'live-measured, never fabricated' provides valuable behavioral context about data provenance that annotations alone do not convey.

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

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

The description is two sentences with no filler, front-loads the read-only nature, and packs the key differentiators (live-measured, never fabricated) compactly. Every clause earns its place.

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

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

Given the simple tool shape, 100% schema coverage, and safety annotations, the description covers the primary output (rank positions and opportunities) and data reliability. It is slightly incomplete in that it does not explain behavior when no parameters are supplied, but overall it provides enough context for safe invocation.

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

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

Schema description coverage is 100%, so parameters are already well documented in the input schema. The description adds no extra parameter-level meaning beyond 'target keywords' and 'measured positions', 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 a specific verb and resource: 'read-only organic rank check' plus 'winnability-ranked opportunities' computed from measured positions. It also adds the distinguishing guarantee that positions are live-measured. However, it does not explicitly differentiate itself from related siblings like keyword_gaps or war_room.

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 a use case — checking organic ranks and opportunities — but gives no explicit guidance on when to prefer this tool over siblings, no exclusions, and no named alternatives. An agent must infer when this is the right choice.

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

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

Annotations already mark readOnlyHint=true, and the description reinforces that with 'Read-only — never uploads or pushes assets,' adding a concrete behavioral guarantee beyond the annotation. It also discloses the kinds of results returned (count, score, grade, levers), which is useful given there is no output 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 short and front-loaded with the core purpose and result payload. Slight redundancy exists with 'Read-only' appearing twice, but the second mention adds the meaningful 'never uploads or pushes assets' clarification.

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

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

For a simple read-only tool with three fully documented parameters, the description covers the key context: scope, safety, and result categories. The absence of an output schema is partially mitigated by listing count, score, grade, and levers, though exact return formatting is not specified.

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

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

Schema description coverage is 100%, so the parameters are already well documented. The description does not add parameter-level detail, but none is needed for the baseline since the schema fully covers query, country, and bundleId.

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: it scores screenshots in the app's live store gallery and reports count, score, grade, and improvement levers. This is specific and differentiates it from siblings like keyword_gaps or audit_app, which cover different concerns.

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 use when screenshot coverage analysis is needed and explicitly warns that it never uploads or pushes assets. However, it does not name alternatives or explain when to prefer this tool over the audit or preview siblings, leaving usage guidance mostly implicit.

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

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

Annotations already declare readOnlyHint and openWorldHint, and the description reinforces this by stating it 'Reads stored data + live competitor ranks; writes nothing.' This adds useful context about what data sources are involved without contradicting the annotations.

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

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

The description is two concise sentences with no filler. The key constraints and behavior are front-loaded, making it immediately scannable for an agent.

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

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

For a read-only comparator with two parameters, the description explains the input context and the nature of the comparison well. It does not detail output format or pagination, but since there is no output schema and the tool is simple, this is a minor gap rather than a critical omission.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds framing by clarifying that appId refers to 'one of YOUR connected apps' and that competitors are compared on the same tracked keywords, but it does not provide substantial new parameter semantics beyond the schema.

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

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

The description clearly names a specific resource (one of your connected apps) and a specific action: comparing your tracked-keyword rank history against live competitor positions on the same keywords. It also immediately marks the operation as read-only, which distinguishes it from audit or update tools.

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

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

It clearly states when to use this tool: when you want a head-to-head rank comparison for one of your own connected apps using tracked keywords and live competitor ranks. It does not explicitly name alternatives or provide when-not-to-use guidance, so it stops slightly short of full guidance.

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