AppSkyline

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

The description goes beyond the annotations by spelling out the concrete consequence of non-idempotency: calling with the same term twice creates two keyword rows. This is valuable behavioral context beyond idempotentHint=false and destructiveHint=true, and it is consistent with those 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. It front-loads the primary action and resource, then immediately conveys the most important behavioral caveat. Every sentence contributes necessary 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 mutating tool, the description covers the required confirmation, the state change, and the duplicate-row consequence. The input schema documents the parameters, and an output schema exists, so no essential guidance is missing 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 description coverage is 100%, so all parameters are already documented with clear semantics. The description adds no individual parameter-level detail beyond what the schema provides, which fits the baseline score of 3 for tools with complete schema coverage.

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

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

The description clearly states the action ('Add') and the specific resource ('a new tracked keyword to an Appskyline app'). It also distinguishes the operation from sibling tools like delete_keyword and list_keywords. The behavior is specific and not a tautology of the tool name.

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

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

The description provides clear context by stating the tool should be used 'after explicit confirmation,' which is a meaningful precondition for a state-changing operation. It does not explicitly name alternative tools or state exact when-not conditions, but the intended use is nevertheless clear from the sibling context and the action itself.

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

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

The description adds substantial behavioral detail beyond the annotations: idempotence on already-deleted keywords, that only future snapshot collection stops, and that historical rows are unaffected. This is exactly the side-effect information an agent needs for 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, no wasted words, and the primary action and scope are front-loaded. Idempotence and boundary-of-effect details follow naturally without bloating the description.

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 required parameter and an output schema, the description covers what is deleted, key side effects, idempotence, and what is not affected. An agent has everything it needs to call this tool correctly.

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

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

Schema description coverage is 100%, and the single id parameter is already described as 'Keyword id to delete.' The description adds little beyond saying 'by id,' so the schema carries the semantic weight.

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: 'Permanently delete a tracked Appskyline keyword by id.' It clearly separates this destructive action from read-only and creation siblings like add_keyword, list_keywords, and get_keyword_history.

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 clarifies that the tool stops collecting new ranking snapshots and leaves historical search rows untouched, giving useful context for when it is appropriate. No explicit sibling alternative is named, but the delete-and-stop-tracking purpose is clear.

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

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

Annotations already declare read-only, idempotent, and non-destructive. The description adds useful behavioral context by noting the output is Markdown-formatted and lists the fields returned (name, locales, per-store ids, creation/edit times), exceeding what structured metadata alone provides.

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

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

A single front-loaded, information-dense sentence. It opens with the core action, then the result format, with no filler or redundant explanation.

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 parameter and an existing output schema, the description together with annotations and schema covers the essential behavior. It could be slightly more complete by explicitly steering the agent to list_apps, but nothing crucial 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 the only parameter appId already includes a meaningful description ('App id (uuid)'). The description doesn't need to add parameter semantics, so a 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 states a specific verb ('Fetch'), a resource ('a single Appskyline app'), and the selection criterion ('by id'). It is clearly distinct from list-style siblings like list_apps, though it doesn't name any alternative.

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 context is clear for a direct single-app lookup, and the phrase 'single ... by id' implies when to use it, but no explicit alternatives or exclusions such as list_apps are mentioned. Guidance is implied rather than fully spelled out.

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 annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds genuine behavioral value by disclosing the return envelope (aggregate totals, recent daily rows, top territories) and the important per-store caveat that metric names differ by store. This is a real gotcha that would trip an agent unaware of 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?

Three sentences, each earning its place: purpose statement, return-value preview, and the per-store metric-naming caveat. There is no redundancy, filler, or repetition of schema content, and the verb-priority front-loading makes the purpose immediately clear.

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 is largely self-sufficient: it explains what the tool returns, scopes it to the required app/store identity, and flags the most likely source of confused expectations (store-specific metric names). The output schema explains the return values, and annotations cover the safety profile. A small residual gap is that the interplay among days, startDate, and endDate is left entirely to the schema without a hint about precedence.

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 carries fully documented parameters (appId, store, days, startDate, endDate). The description confirms the app/store/date-window scope but adds no new parameter-level meaning beyond what the schema already provides. A baseline 3 is correct for a schema that 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 ('Summarize') with a concrete resource and scope: downloads, installs, uninstalls, crashes, and other store-reported engagement totals for one Appskyline app over a date window. The metric list and the single-app/single-store scope make it readily distinguishable from siblings such as keyword tools, list_apps, and store-listing 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 clear context for when the tool applies: pulling store-reported engagement totals for a single app over a date range. There are no explicit exclusions or named alternatives, but the metric scope ('downloads, installs, uninstalls, crashes') plus the per-store reporting caveat is enough for an agent to route to this tool rather than a keyword or metadata 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?

Annotations already establish the tool is read-only, idempotent, and non-destructive. The description adds useful context by specifying that it returns a Markdown table of date, rank, and total results scanned per day, and clarifies it is based on day-by-day snapshots stored by Appskyline. No contradictions with annotations are present.

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, no filler, and the key action is front-loaded in the first sentence. The second sentence names the concrete return format only, so every word earns its place.

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

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

Given the read-only annotations, complete input schema, and the existence of an output schema, the description gives enough information for an agent to call and interpret the tool. It covers scope, time granularity, and the Markdown table output without requiring excessive inference.

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 gives full descriptions for all parameters, including terms, store enums, country codes, and the limit behavior. The description adds no new parameter-level detail beyond restating the app, term, and country context. Since schema coverage is 100%, 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 uses a specific verb and resource: it gets the historical ranking timeseries for an app, term, and country across day-by-day snapshots. This clearly differentiates it from sibling tools like get_keyword_rank by emphasizing 'historical' and 'day-by-day' data. The return format is also stated, leaving no doubt what the tool does.

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

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

The description clearly implies this is for historical rank trends rather than current rank lookup, which is enough to distinguish it from get_keyword_rank. However, it does not explicitly say 'use this instead of X' or state exclusions, so it stops short of giving full decision 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?

Beyond the read-only/idempotent annotations, the description discloses a meaningful behavioral trait: values come from a shared cache and stale/missing terms cause a live upstream lookup that is billable. This directly informs cost-sensitive billing behavior and is exactly the kind of context annotations cannot provide.

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

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

The description is concise and front-loaded with the core purpose, then follows with the important caching and billing caveat. Two sentences carry the full message with no fluff, though it could arguably be more structured with explicit parameter mapping.

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 input schema covers all parameters, an output schema exists, ans the annotations cover safety, the description adds the one missing strategically important piece: billing behavior around cache misses. Nothing essential for an agent to call this tool 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?

Because schema description coverage is 100%, the schema already documents terms, country, and lang. The description adds practical semantics by stating the tool handles 'up to 50 search terms in one country' and stresses batching to avoid per-keyword bills, which gives extra meaning to the terms parameter beyond its schema constraints.

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

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

The description clearly specifies the action ('Look up monthly search volume, keyword difficulty, CPC and competition level') and the resource (up to 50 search terms in one country). It differentiates the tool's overview function from keyword history or ranking tools, though it does not explicitly name sibling 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 clear usage context: terms should be batched, max 50, single country at a time, and callers should avoid calling once per keyword. It does not explicitly say when to use this tool over sibling tools like get_keyword_history or list_keywords.

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?

Given the readOnlyHint and idempotentHint annotations, the description still adds useful behavioral detail by describing the exact result string, including the boundary behavior: 'not in top N' if the app is absent from the scanned results. This clarifies how the optional num parameter affects the outcome.

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, tightly worded sentence that front-loads the purpose, then provides the expected return format and edge-case behavior. Every clause adds value 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?

The tool has strong annotations, an output schema, and a sufficiently descriptive parameter schema, so the description does not need to explain every return field. It covers the main lookup goal and the most important edge case (app not found), making it adequate 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?

Although schema coverage is 100%, the description adds important meaning by clarifying that 'term' is the keyword, especially since the schema text for 'term' appears mislabeled as a language code. It also connects 'num' to the 'top N' behavior, which helps the agent understand the parameter's practical effect.

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 ('Look up') and identifies the exact resource: the current ranking of a specific Appskyline app for a keyword in a given store and country. It clearly distinguishes this from sibling tools such as get_keyword_history or get_keyword_overview by emphasizing 'current ranking.'

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 context is clear: this is the tool to use when you need a current, point-in-time rank for a specific app-keyword-store combination. It does not explicitly name alternatives or when not to use it, but the 'current ranking' phrasing makes the intended usage obvious 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?

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false, so the safety profile is covered. The description adds useful behavioral context: the listing is public, available for any store-native id, and includes truncated description/release notes. 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?

Two tight sentences. The first front-loads the action, resource, scope, and key fields; the second adds the primary use case. There is no redundancy or irrelevant prose.

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 combined with the fully documented schema and output schema gives an agent everything needed to invoke the tool correctly. It covers the operation's purpose, scope, parameter meaning, and return-field expectations without requiring additional explanation.

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 provides rich documentation for all four parameters, including the enum for store and details on the storeId format (Apple id, Google Play package, Microsoft product id). The description adds no parameter-specific guidance, but with 100% schema coverage the baseline is met.

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 and resource ('Fetch the public store listing for any app by its store-native id'), enumerates the fields returned (title, developer, rating, price, version, etc.), and explicitly differentiates itself from app-tracking tools with 'not just apps tracked in Appskyline'. This is unambiguous and distinguishable from siblings like 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?

It states a clear use case ('competitor research') and clarifies scope ('any app'), which guides when to use it. It doesn't explicitly name alternatives or state when not to use it, but the sibling names and this scope description provide sufficient 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?

Annotations already declare readOnlyHint=true and idempotentHint=true. The description adds meaningful detail: it specifies 'Appskyline has synced' (indicating cached data) and 'never downloads from or uploads to the store,' reinforcing and extending the annotation. It also highlights the keyword character-count check against Apple's 100-character limit, providing extra behavioral context 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 two concise sentences, front-loaded with the core purpose and followed by relevant details. Every phrase earns its place: the field list is specific but not redundant, and the read-only assurance is placed at the end without padding. No fluff 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?

For a read-only tool with an output schema and full parameter descriptions, the description sufficiently covers what data is returned and the safe behavior. It mentions the synced nature and the character-limit detail. It doesn't discuss error conditions or rate limits, but given the tool's simplicity and the presence of an output schema, this is not a significant gap. Could add a note about default locale behavior but is already complete enough.

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 three parameters (appId, store, locale) with 100% coverage. The description's mention of 'per locale' complements the locale parameter, and the listing of fields hints at the store parameter's role, but it doesn't add deeper meaning about parameter values or constraints. Since schema already documents the parameters, 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 opens with 'Read the store-listing metadata' — a clear verb and resource — and enumerates the exact fields returned (per locale name, subtitle, keywords with character counts, promotional text, release notes, version, review state). It also states 'Read-only: it never downloads from or uploads to the store,' which distinguishes it from sibling tools like get_store_listing, making its purpose unambiguous.

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

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

The description provides clear context: it reads synced metadata from Appskyline, implying its use when cached listing data is needed. It explicitly states it is read-only and never contacts the store, which signals a safe, non-mutating operation. However, it doesn't name alternative tools or explicitly state when NOT to use it, so it lacks the full when/when-not guidance that would earn 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 read-only, idempotent, non-destructive behavior. The description goes beyond annotations by explaining the Markdown table return format and which fields are included, and the 'when set' qualifier for per-store ids is a useful behavioral detail.

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 the core purpose front-loaded and the return format described in one compact follow-up. Every phrase adds useful information 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?

For a parameterless, read-only, output-schema-bearing list tool, the description is complete: it defines the scope of results, names the return format, and lists the exact fields. No additional detail seems necessary for an agent to 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?

The tool has zero parameters and the schema documentation coverage is 100%, so there is nothing for the description to clarify about parameters. The description correctly focuses on behavior and result format instead.

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

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

The description clearly states the action ('List all...apps'), the specific resource ('Appskyline apps'), and the access scope ('authenticated user has access to'). It also specifies the exact return content, which fully disambiguates it from sibling tools like 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?

The description gives clear enumeration context: it lists all apps the user can access, which implies a high-level overview use case. It does not explicitly name an alternative for retrieving a single app's details, but the scope is clear enough that an agent could infer when this tool fits.

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 read-only, idempotent, and non-destructive behavior. The description adds genuinely useful behavioral context: the service account requirement, 'most recent' ordering, truncated review text, and pagination via a returned page token. This goes beyond what the annotations alone provide.

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

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

The description is compact and information-dense: the first sentence states purpose and output fields, the second covers the prerequisite, and the third explains pagination. There is no filler or unnecessary 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?

Combined with the complete parameter schema, output schema, and annotations, the description covers the essential context an agent needs: what the tool returns, which app scope it applies to, the service account requirement, and how to paginate. No critical decision or invocation information 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 four parameters already have meaningful descriptions. The tool description does not add significant parameter-level semantics beyond the natural context of 'most recent reviews' and pagination, 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 states exactly what the tool does: lists recent Google Play reviews for an Appskyline app, and enumerates the returned fields (star rating, truncated text, app version, device, language, reply status). This clearly distinguishes it from sibling tools such as list_apps and list_keywords.

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 context: it is for fetching reviews for a specific app, requires a configured Google Play service account, and uses pagination. It does not explicitly compare against alternatives, but the sibling tools are clearly about different resources, so the invocation situation is readily inferable.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safe read profile is established without relying on the description. The description adds useful detail about the Markdown-table response format and column contents, but does not go beyond that into additional behavioral 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?

Two concise sentences front-load the main purpose and include the most useful additional detail, the Markdown table output with its fields. There is no redundant wording 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?

For a simple read-only list operation, the description is complete: it names the resource, the app scoping, and the output format. Pagination is covered by the input schema, and return-field details are covered by 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 description coverage is 100%, so appId, skip, and limit are already documented in the schema. The description's mention of searchTerms clarifies an output field, not the parameters, so it adds no parameter-level meaning beyond the schema. Baseline 3 is appropriate.

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

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

The description states a specific verb ('List'), a clear resource ('tracked keywords for an Appskyline app'), and details the returned columns and format. This clearly distinguishes it from sibling tools like add_keyword and delete_keyword without requiring further inspection.

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 this is the read operation for retrieving tracked keywords, which is adequate context for selecting it over add/delete keyword tools. It does not explicitly name alternatives or exclusions, but the sibling set and the clear list semantics provide enough 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 annotations already declaring readOnlyHint=true and idempotentHint=true, the description still adds valuable behavioral context: it is a 'live' search (results are real-time, not cached) and it does not persist the result ('without storing a search snapshot'). It also discloses the exact return format (Markdown table). This goes beyond simple safety annotations and aligns with them.

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 efficient sentences. It front-loads the core action and scope, immediately states a key negative behavior ('without storing a search snapshot'), and then gives the return format. Every clause adds value with no repetition 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?

Given the tool's moderate complexity, the rich schema (all param docs), annotations (read-only, idempotent), and output budget schema, the description covers everything essential: the stores, the live/non-persisting behavior, and exact output format. Nothing critical is missing for an agent to decide whether 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?

Schema description coverage is 100%, and each parameter is clearly documented with names, types, constraints, and examples. The description adds minimal extra parameter detail beyond the schema (only human-readable store names), 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 specifies the exact action ('Run a live ranked search'), the resource (app store results across iOS App Store, macOS App Store, Google Play, or Microsoft Store), and the key distinguishing trait ('without storing a search snapshot'). This clearly separates it from store-specific history or overview tools among the siblings, even without naming them.

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 that this tool is for live, current-ranked searches and explicitly notes it does not store a snapshot, which implies when to use it over snapshot-based sibling tools like get_keyword_history. However, it does not explicitly name alternatives or state 'when not to use', so it falls just short of a perfect score.

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

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

Annotations already provide readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds some useful behavioral context ('interactive overview', 'up to 50 tracked keywords'), but does not disclose much beyond that. This is adequate but not rich.

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

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

Two short sentences, with the primary action front-loaded and a snippet about usage following immediately. Every clause adds value, with no filler or repeated schema data.

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

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

For a single-parameter, read-only overview tool with a full output schema, the description is complete. It states when to use, what it shows, and the key constraint of a 'known' app. Combined with strong annotations and output schema, no critical contextual information 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 the single appId parameter is documented as 'Appskyline app id to render.' The description reinforces this by saying 'when the user provides an Appskyline app id,' but does not add substantial meaning beyond the schema, 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 uses a specific verb ('Render') with a clear resource ('interactive overview for a known Appskyline app'), and states the content scope ('store identities and up to 50 tracked keywords'). It clearly distinguishes itself as an overview tool rather than a data-retrieval or mutation tool.

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

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

The description gives clear context for when to use the tool: 'after listing apps or when the user provides an Appskyline app id.' It doesn't explicitly compare to siblings like get_app or get_store_metadata, but the use-after-listening guidance is enough for an agent to route invocation correctly in most cases.

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