AppSkyline

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

Annotations already declare destructiveHint=true, idempotentHint=false, and readOnlyHint=false, lowering the bar. The description nonetheless adds non-obvious behavior: duplicate terms create two rows, and keywords lacking a country are skipped by the weekly rank check. It stops short of permissions or rate-limit 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?

Three tight sentences, front-loaded with the use case, then return/side-effect facts, then the exclusion. Every sentence carries distinct information with 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 annotations covering the safety profile and an output schema covering the return value, the description supplies the remaining essentials: trigger condition, duplicate behavior, and a sibling exclusion. Only minor gaps (auth or quota expectations) remain.

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 appId, country, language, and searchTerms with examples. The description only reinforces the country-skip rule that the schema already states, adding little new semantic value; baseline 3 applies.

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

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

The description names a specific verb and resource ('start tracking a keyword for their app in a given language and country') and explicitly distinguishes from a sibling action ('Not for a one-off rank lookup', i.e. get_keyword_rank). An agent can route without opening the schema.

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

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

It states the trigger condition ('when someone asks to start tracking a keyword'), names the alternative tool's domain implicitly, and gives a negative case ('Not for a one-off rank lookup'). Both when-to-use and when-not-to-use are present.

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?

Adds substantial context beyond the destructive/idempotent annotations: it discloses the return values (deleted, not-found), that weekly rank checks stop, that past snapshots are retained, and that a gap appears if the keyword is re-tracked. This is exactly the side-effect detail an agent needs before a destructive call.

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 load-bearing: trigger, outcome values, side effects, and exclusion. The usage trigger is front-loaded and 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?

Annotations cover the safety profile and an output schema exists, yet the description still supplies the non-obvious behavioral consequences (snapshot retention, re-track gap) and the return values. Nothing needed to call this correctly is missing.

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

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

Only one parameter with 100% schema description coverage, so the schema fully carries the 'id' semantics. The description adds no format or sourcing detail about the id, so the baseline 3 applies.

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

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

States a specific verb and resource: stopping tracking of one keyword, backed by the title/name. It contrasts itself against a pause operation, which sharpens the scope, though it never names a sibling tool from the provided list.

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 'Use this when...' trigger for stopping keyword tracking, plus an exclusion ('Not for pausing tracking temporarily'). It stops short of naming the alternative tool for temporary pauses, so the routing guidance is clear but not fully enumerated.

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

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

Annotations already declare readOnlyHint/idempotentHint/destructiveHint=false and openWorldHint=false, so safety is covered. The description adds value by scoping what data is exposed (locales, per-store ids, timestamps) and by explicitly ruling out live store pages and ratings, which prevents misuse. It says nothing about auth scope or error behavior for an invalid appId.

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, front-loaded with the use case, then the return payload, then the negative boundary. No filler and nothing buried.

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 one-parameter read-only getter with a full output schema and rich annotations, the description supplies everything needed: when to call it, what it returns, and what it is not for. Return-value documentation is correctly left to the 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% and the single appId parameter is fully documented as a UUID in the schema, so the baseline applies. The description's phrase 'one of their AppSkyline apps' lightly reinforces that appId must be a user-owned app id, but adds no format or constraint detail 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?

States a specific verb+resource ('get app details' for a single AppSkyline app) and enumerates exactly what it returns: name, locales, per-store ids, and creation/edit times. That enumeration cleanly separates it from list_apps (plural) and from the store-listing/metadata 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?

Gives a concrete triggering situation ('someone asks about one of their AppSkyline apps, such as which stores it is on or which languages it supports') and an explicit exclusion ('Not for the live public store page or ratings'). It stops short of naming the sibling tools (get_store_listing, get_store_metadata) that should be used instead, leaving a small inference gap.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), so the description's value is in the result shape it discloses: store-reported totals, the latest 30 daily rows, top countries, and the caveat that metric names differ by store. That last point is a genuine gotcha an agent could not infer from annotations, though the return contract is partly redundant with the 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?

Three tight sentences, front-loaded with the invocation trigger, then the return shape, then the exclusion. No filler and every clause carries information.

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

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

With a full schema, an output schema, and annotations present, the description needs only to add trigger, scope, and caveats — which it does. An agent has enough to pick this tool and call it correctly.

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

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

Schema description coverage is 100%, including the days/startDate/endDate interaction and the store enum, so the schema carries the parameter burden. The description only restates scoping at a high level ('for one app and store', 'over a period') without adding format or precedence detail beyond what the schema already documents.

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 concrete trigger and names the exact resources it reports on (downloads, installs, uninstalls, crashes) over a period, which is more specific than the title's 'downloads and installs'. It also explicitly carves itself away from sibling territory with 'Not for keyword rankings.'

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

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

It states a clear when-to-use condition ('when someone asks how many downloads, installs, uninstalls or crashes their app had over a period') and one negative exclusion. It stops short of naming the positive alternative for a broader app picture (e.g. show_app_overview or get_app), so the routing is implied rather than complete.

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

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

Annotations already declare readOnly/idempotent/non-destructive, and the description adds genuinely new behavioral context: rank is returned per stored snapshot, newest first, capped at 365 rows, and tracked keywords are only re-checked weekly. That freshness cadence is exactly what an agent needs to interpret stale results.

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 tight sentences, front-loaded with the usage trigger, then return shape, then the exclusion. Every sentence earns its place with 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 an output schema present, the description needn't explain the response payload, and annotations cover safety. Combined with the freshness cadence and row cap, an agent has everything required to call this correctly and interpret 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 description coverage is 100%, so all five parameters (including term, store enum, country, limit) are already documented in the schema. The description restates the one-store/one-country scope but adds no syntax or format detail beyond the schema, so baseline 3 applies.

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

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

States a specific verb and resource (retrieve an app's keyword rank history over time) and pins the scope to one store and one country. It is clearly distinguishable from siblings like get_keyword_rank (live rank) and get_keyword_overview.

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 an explicit trigger ('when someone asks how their app's ranking ... has changed over time') and an explicit exclusion ('Not for today's live rank'). It stops short of naming the alternative tool an agent should use for live rank, so it is clear but not fully routed.

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

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

Annotations already declare readOnlyHint, idempotentHint and destructiveHint=false, so safety is covered; the description goes beyond them by disclosing the billing side effect (cache misses trigger a billable lookup) and the 30-day cache window. It does not mention rate limits or latency, so it stops short of a 5.

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, front-loaded with the trigger, then the payload, then the cost caveat and the exclusion. Every sentence carries distinct information with 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?

An output schema exists, so return-field detail is not required, yet the description still summarizes what comes back. Combined with the billing disclosure, batch limits, country scoping and the ranking exclusion, an agent has everything needed 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?

Schema coverage is 100%, so the schema already documents terms, country and lang including the 50-item cap and code patterns. The description restates 'up to 50 terms in one country' and adds the useful point that a batch is scoped to a single country, but contributes little else 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?

States a specific verb+resource (look up keyword search volume) and enumerates the returned metrics: monthly Google web-search volume, difficulty, CPC and competition. It also preempts a likely confusion by clarifying this is a demand proxy rather than app-store search counts, which separates it from the app/store 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?

Opens with an explicit trigger ('when someone asks how popular a keyword is or which keyword ideas are worth targeting') and closes with an exclusion ('Not for rankings'), routing the agent to get_keyword_rank. The batch constraint (up to 50 terms in one country) further bounds correct 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?

Annotations already declare readOnlyHint, idempotentHint and destructiveHint=false, so safety is covered. The description adds real behavioral context beyond that: it scans the top 50 by default, up to 200, and returns a live position or a not-ranked result, plus mentions rendering a rank card.

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 tight sentences with zero waste, front-loaded with the triggering condition and then the return behavior and exclusion. 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?

With a rich annotation set and an output schema present, the description need not explain the return payload; it nonetheless signals the rank-card rendering and the not-ranked case. Nothing an agent needs to invoke this correctly is missing.

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

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

Schema description coverage is 100%, so all six parameters (including defaults, enums and limits) are already documented in the schema. The description only restates the scan default and ceiling, adding no syntax or meaning beyond the structured 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?

States a specific verb (check/return) and resource (an app's live keyword rank) plus the scope (one store and country, right now). The final clause explicitly separates it from get_keyword_history, so an agent can distinguish it from the sibling without opening either schema.

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

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

"Use this when someone asks where their app ranks for a keyword right now" gives a clear triggering context, and "Not for how a rank changed over time" supplies an explicit exclusion. It does not name get_keyword_history directly, so the routing is described rather than pinned to a sibling name.

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

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

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so the safety profile is covered. The description adds genuinely new behavior: the result is a live listing, and description and release notes are truncated at 600 characters — a constraint an agent cannot learn from the schema or annotations.

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

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

Three short sentences, front-loaded with the usage trigger, then the return shape, then the exclusion. Every sentence carries information; only the closing clause is slightly elliptical about what "synced text per language" refers to.

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?

An output schema exists, so return values need no elaboration, and the description still adds the truncation caveat and the live-vs-synced distinction. For a four-parameter read tool with full schema coverage, nothing needed to call it correctly is missing.

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

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

Schema description coverage is 100% and each parameter is documented (lang, store, country, storeId). The description only adds the framing of "one store id" and hints at language via the exclusion clause, which is marginal over the schema. Baseline 3 applies.

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

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

The description names a specific verb (read) and resource (a public store listing) and enumerates the fields returned — rating, number of ratings, price, version, last update. It also distinguishes itself from sibling read tools like get_store_metadata and search_store_results by scoping to a single store id's live public page.

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 an explicit trigger ("when someone asks about a competitor's or any app's public store page") and an exclusion ("Not for your own app's synced text per language"). It never names the sibling tool that handles the excluded case, so the agent must infer the alternative rather than being routed to it.

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

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

Annotations already establish read-only/idempotent/no-destruction, and the description adds genuinely new behavioral context on top: the data is mirrored from the last AppSkyline sync (staleness), long texts are truncated at 600 characters, and it reports keyword length against Apple's 100-character limit. Those are non-obvious traits an agent would otherwise discover only at runtime.

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?

Front-loaded with the triggering condition, then the payload facts, then a one-clause exclusion. The middle sentence is dense with semicolon-joined clauses, but every clause carries information (returned fields, review state, keyword limit, truncation cap), so the size is justified.

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 three-parameter, fully annotated read tool with an output schema, the description supplies everything needed to select and call it: trigger condition, scope, locale semantics, sync staleness and truncation behavior. It even over-delivers slightly on return values, which the output schema already covers.

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 appId, store and locale are all documented in the schema itself, which sets the baseline at 3. The description reinforces locale behavior (per-language text, every synced locale when absent) but adds no syntax or format detail beyond what the schema already states.

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 verb and resource: reading back per-locale listing text (title, subtitle, keywords, release notes) plus the review state of the latest version. It scopes the tool to "their own app's" data and ends with a contrastive boundary ("Not for a live competitor listing"), so an agent can separate it from listing-scraping 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?

Usage is triggered explicitly ("Use this when someone asks about their own app's listing text per language... or whether the latest version is still in review") and one exclusion is given. However, the more ambiguous sibling get_store_listing is never named or contrasted, leaving the agent to guess between two closely related listing tools.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds a real behavioral constraint beyond the structured data: the result is capped at 'up to 100 apps', which tells the agent to expect truncation. It stops short of explaining ordering or pagination behavior, so not a full 5.

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 tight sentences, front-loaded with the usage trigger, then the return contents, then the exclusion. Every sentence carries information an agent would otherwise have to guess.

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 parameters, a present output schema, and annotations covering safety, the description only needs to supply the trigger, the scope and the sibling boundary — all of which it does. Nothing required for correct invocation is missing.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. The description correctly implies the call is unfiltered and account-scoped rather than accepting query arguments.

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?

Specific verb+resource (list the apps tracked in AppSkyline) with an explicit enumeration of the returned fields, plus a negative scope statement ('Not for finding other apps in a store') that separates it from search_store_results. An agent can identify and use it without opening the schema.

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

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

States the trigger condition ('when someone asks which apps they track... or an app's id is needed') and names the condition under which it is the wrong tool ('Not for finding other apps in a store'). Both when-to-use and when-not are explicit.

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

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

Annotations already declare readOnly/idempotent/non-destructive, so the safety profile is covered. The description adds genuinely non-obvious behavior: a hard 7-day retention window on Google Play's side and 300-character truncation of review text. It does not mention rate limits or what happens when a page token expires, which keeps it short of a 5.

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, front-loaded with the usage trigger, then return shape, then the platform constraint and exclusion. Every sentence carries distinct information and nothing is repeated from the schema.

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

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

With annotations covering safety, a full input schema and an output schema, the description only needs to supply routing, retention limits and truncation behavior — which it does. An agent has everything required to call this correctly and interpret 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 description coverage is 100%, so appId, token, maxResults and translationLanguage are already fully documented in the schema. The description only restates the page size ('up to 100 per page') and implies the pagination flow, adding no syntax or format detail beyond structured fields. 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?

States a specific verb and resource (read Google Play reviews) and immediately distinguishes itself from the nearest lookalike with 'Not for App Store reviews.' It also enumerates the exact payload (stars, truncated text, app version, device, language, developer reply), so an agent knows what it gets without opening the output schema.

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

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

Gives an explicit trigger ('when someone asks what users say about their Android app on Google Play, or about recent ratings and complaints') plus an explicit when-not ('Not for App Store reviews'). No relevant competing sibling exists in the tool list, so no further routing is needed.

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

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

Annotations already declare readOnly, idempotent and non-destructive, so safety is covered. The description adds real behavioral context the annotations lack: the returned field set and the 500-per-call ceiling. It does not discuss paging behavior beyond what the schema says, keeping it short of a 5.

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, front-loaded with the usage trigger, followed by return contents and then the exclusion. Every clause earns its place with no restatement of the tool name or title.

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 list tool with a full output schema and annotated safety profile, the description supplies the routing context, return fields, and cap. Nothing needed to invoke it correctly is missing.

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

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

Schema coverage is 100% and each parameter (skip, limit, appId) is documented in-schema with bounds. The description only reinforces the cap ('up to 500 per call'), which is already implied by the limit maximum, so the baseline 3 applies.

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

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

States a specific verb (list) and resource (tracked keywords) scoped to an app, and explicitly excludes adjacent capabilities: 'Not for current rankings or search volume.' An agent can separate it from get_keyword_rank and get_keyword_overview without opening a schema.

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

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

Gives an explicit trigger ('when someone asks which keywords they track for an app') plus a workflow trigger ('before adding or deleting one') that routes to add_keyword/delete_keyword, and names what it is not for. Nothing is left to inference.

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

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

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so the safety profile is covered. The description adds real context beyond them: results come back in rank order with specific fields, are live, and default to 10 with a ceiling of 200.

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, zero filler, with the usage trigger front-loaded and the return shape and exclusion packed into the second. Nothing is repeated.

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 five-parameter read tool with an output schema, annotations and a full schema description coverage, all that is needed to select and invoke it is present: when to use, when not to, or which stores, and result-size bounds.

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 store, term, num, lang and country are all documented in the schema itself. The description only restates the num default (10, up to 200) and the store list, which duplicates schema content rather than adding syntax or format guidance, so the baseline 3 applies.

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

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

States a precise verb+resource ('search' an app store) and enumerates the four supported stores, immediate scope. Naming the exact question it answers ('which apps show up for a search term') separates it cleanly from siblings like get_store_listing and get_app.

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 positive trigger ('when someone asks which apps show up for a search term, or who their competitors are for a keyword') plus an explicit exclusion ('Not for one app's own position'), which routes the agent away from this tool for single-app lookups.

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

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

Annotations already declare readOnly, idempotent, non-destructive, closed-world, so the safety profile is covered. The description adds genuinely useful behavior beyond that: the 50-keyword cap on the returned card, which tells the agent the result is truncated rather than complete.

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, trigger first, payload second, exclusion last. No filler and nothing buried.

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 an output schema present, return values needn't be spelled out, and annotations cover the safety profile, so the definition is nearly complete for a one-parameter read. The only meaningful gap is that it never positions itself against get_app or list_apps.

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 single appId parameter is documented as a uuid in the schema, so the schema carries the load. The description adds nothing about appId format or where to obtain it, 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?

Names a specific verb+resource (show an overview of a tracked app) and enumerates the payload: connected stores, locales, and up to 50 tracked keywords. It rules out keyword rankings, but never distinguishes itself from the closest sibling, get_app, leaving the agent to guess between two app-scoped reads.

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?

"Use this when someone wants a quick overview" is an explicit trigger, and "Not for keyword rankings" is an explicit exclusion that routes ranking questions elsewhere. It stops short of naming the alternative tool for rankings or explaining when get_app is preferable.

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