OneStore

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

Annotations already declare readOnly, idempotent, and non-destructive, so the bar is lower. The description still adds real value by clarifying that the tool performs a pure completeness check and will not apply declarations or fixes, which is exactly the mutation boundary an agent needs to know. It stops short of saying what the check returns.

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

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

Two short sentences, front-loaded with the action and followed by the exclusion. No wasted text, though the phrasing 'Read Apple submission completeness' is slightly compressed and could read more explicitly.

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?

There is no output schema, so the description carries the burden of explaining what a 'completeness' result looks like, and it does not. Combined with fully undocumented parameters, an agent knows the intent but not the inputs or the shape of the answer.

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 0% for both appId and releaseId, and the description never mentions either parameter. With two undocumented required identifiers, the description should clarify which submission identifiers are expected but contributes nothing here.

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 ('Apple submission completeness'), so an agent can tell this is a validation/inspection operation on a submission. It lacks explicit differentiation from siblings such as get_app or list_releases, relying only on the negative clause about compliance declarations.

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

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

The phrase 'Does not apply compliance declarations or fixes' implies a boundary (read-only check, not remediation), but no alternative sibling is named for the fixing step, and no prerequisites or when-to-use context is given. Usage is only 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 readOnly, idempotent, non-destructive, and closed-world behavior. The description adds useful context about returned metadata and sync timestamps, but does not describe authentication needs, not-found behavior, or other behavioral edge cases.

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 sentence with no filler. Every phrase contributes meaning to what the tool returns.

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 getter with rich annotations, the description is adequate but leaves gaps: appId semantics are undocumented and error/absence behavior is unstated. The lack of an output schema makes the brief return-content summary more valuable, but still incomplete.

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 0%, and the description never mentions appId, its required status, or format expectations. The one parameter is named clearly enough to infer its role, but the description does not compensate for the missing schema documentation.

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

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

Uses a specific verb ("Read") and resource ("application metadata") plus a meaningful detail about synchronization timestamps. It distinguishes itself reasonably from list_apps and get_app_metrics, 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 no explicit guidance on when to use this tool instead of siblings such as list_apps, get_app_metrics, or get_sync_job. The single-app retrieval use case is implied but not stated.

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

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

Annotations already cover the read-only/idempotent safety profile, and the description adds substantive semantics beyond that: values are cached daily, installs are summed across versions, revenue is net and grouped by original currency, subscriptions are non-additive daily snapshots, and missing rows mean unknown rather than zero.

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

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

Five short sentences, each carrying a distinct fact, with the scope and window stated first and the data caveats following. No filler or restatement of the 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?

With no output schema, the description does the necessary work of explaining return-value semantics (row cap, unknown-vs-zero, currency grouping, micros scaling). Only the platform parameter's role is left unexplained.

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 0%, so the description has to carry the load; it explains the date window (max 90 days, default 30) and the meaning of all three metric enum values, including the amountMicros integer-string convention. It says nothing about appId or the platform enum (APPLE/GOOGLE), leaving those to bare 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 and resource ('Daily cached metrics for one app') plus the window constraint, which cleanly separates it from siblings like get_app and list_reviews. An agent can tell what this returns 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?

Gives clear context for use — per-app daily metrics, defaults to 30 days, capped at 90, 1000-row ceiling — but never names an alternative tool or states when not to use it (e.g. multi-app comparison vs list_apps).

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, destructiveHint=false, and openWorldHint=false, so safety behavior is covered. The description adds useful domain-specific context: current user rights are always intersected with the grant, which helps the agent interpret the returned permissions correctly.

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 short sentences with no wasted language. It front-loads the resource and then adds the key permission-intersection caveat.

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 zero-parameter, read-only tool with full annotation coverage, the description gives enough conceptual context about what is returned: effective permissions and autonomy, with rights intersected against the grant. It does not describe the output shape, but no output schema exists and the core semantic caveat is present.

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

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

This tool takes zero parameters, so the baseline score is 4. There are no parameter semantics to clarify beyond the schema, and the description appropriately stays focused on the result semantics.

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

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

The description uses a specific verb ("Get") and resource ("this connection’s effective permissions and autonomy"), making the tool’s purpose clear. It does not explicitly distinguish itself from siblings, but none of the listed siblings appear to cover connection permissions.

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

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

The description implies usage by stating it retrieves effective permissions and autonomy, but it does not explicitly say when to use this tool versus alternatives or mention any exclusions. The intended use is inferable rather than 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?

Annotations already declare readOnly, idempotent, non-destructive, and closed-world, so the safety profile is covered. The description adds a useful note that it works 'without a locally installed skill,' but says nothing about the return format (prose vs. structured) for a tool with 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?

Two compact sentences with the content list front-loaded and the availability note trailing. No filler, though the second sentence is somewhat niche in value.

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

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

For a simple read-only guide fetch with one enum param and full annotation coverage, the description gives enough for an agent to select and invoke it correctly. The only minor gap is the absence of any return-format expectation, which no output schema supplies.

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 0%, the single enum is self-explanatory and the description maps values to meaning, notably clarifying that 'content' covers listings/screenshots/reviews and 'start' means getting started. This meaningfully improves on the bare enum tokens.

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 (read) and resource (official OneStore workflows) and enumerates the four content areas. It is clearly distinguishable from the data-fetching siblings like get_app and list_listings, though it doesn't explicitly name an alternative to route away from.

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 implied by the topic list ('getting started', 'troubleshooting'), and the availability note hints at context, but there is no explicit when-to-use/when-not or pointer to which sibling handles the actual data operations versus reading guidance.

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

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

Annotations already establish that this is a safe, idempotent, read-only operation. The description adds useful behavioral context by clarifying that only completion state is returned and that provider logs are omitted, which helps set expectations about the response.

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

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

Two short sentences, front-loaded with the core purpose and immediately followed by an important omission note. There is no wasted wording.

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 one-parameter read tool with strong annotations, the description covers the operation and one response caveat. It remains incomplete because it says nothing about the jobId parameter and gives only minimal insight into the return data beyond completion state.

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 0%, and the description never mentions the sole parameter jobId or explains its semantics, format, or constraints. The parameter name is fairly self-explanatory, but the description does not compensate for the missing schema documentation.

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 gives a specific verb and resource: read a push job’s completion state. It is clearer than the bare tool name get_sync_job and narrows scope to completion status, though it does not explicitly differentiate itself from any sibling tool.

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

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

It implies the tool is used to inspect push job status, but never states when to use it, when not to use it, or which alternative tools cover related tasks. The agent must infer usage entirely from the purpose sentence.

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 this as a safe, read-only, idempotent, non-destructive listing operation. The description adds useful behavioral context by stating that results include exact JSON input schemas and that some effects require the publish permission, but it does not describe return shape or pagination behavior.

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

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

Two short sentences, both front-loaded with the key resource and return detail. There is no filler or repetitive wording.

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 zero-parameter, read-only listing tool with no output schema, the description gives enough context: what is listed, that returned actions include exact JSON input schemas, and a permission caveat. It could be slightly more complete by clarifying whether the app is implicit or pagination exists, but nothing critical is missing.

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

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

The tool has zero parameters, so there are no parameter semantics to document; baseline 4 applies. The description's mention of 'one app' does not map to a schema parameter but does not conflict with 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 and resource: list the actions a connection may run on one app, including their exact JSON input schemas. This clearly distinguishes it from sibling list tools such as list_apps or list_releases, though it does not explicitly name an 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?

Usage is implied by the resource being listed, but there is no explicit when-to-use guidance, no exclusions, and no named alternative sibling. The permission note adds context but not selection guidance.

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

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

Annotations already establish readOnly, idempotent, non-destructive behavior, but the description adds useful context beyond them: results are scoped to the current connection and include sync timestamps. It also indicates pagination behavior, though it does not mention rate limits or return ordering beyond pagination by app id.

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

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

The description is a single front-loaded sentence with no wasted language. It quickly conveys scope, returned data, and pagination.

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

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

For a simple paginated list tool with no output schema, the description covers the key facts an agent needs: what is listed, the connection scope, returned timestamps, and pagination basis. The main remaining gap is the lack of parameter-level detail for limit and cursor.

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 0%, so the description must compensate for undocumented parameters. It mentions pagination but does not explain the limit parameter, its default/maximum, or the cursor format, leaving both parameters largely inferred from the schema alone.

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: list applications granted to this connection, with sync timestamps. This distinguishes it from get_app and other list tools, though it does not explicitly name a sibling 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 description communicates the basic scope but gives no explicit guidance on when to use this tool versus get_app or other list_* siblings. There are no exclusions, prerequisites, or alternative-selection cues.

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 the safety profile is covered. The description adds that the result carries exact size constraints, but does not say whether this is static reference data, cached, or account-specific.

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?

One sentence with no filler and the key content front-loaded. It is terse but not padded.

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 carries the burden of hinting at the return value; it does so only loosely ('image slots and their exact dimensions/size constraints') without saying what a slot record contains (key names, formats, limits). Adequate but thin for a lookup tool.

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

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

Zero parameters, so the baseline applies; the description correctly implies no input is needed to fetch the format list.

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 resource ('supported image slots' with 'dimensions/size constraints') and a clear retrieval verb. It implicitly distinguishes itself from list_assets (actual assets vs. format specs), but never names that sibling explicitly.

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?

No statement of when to call this versus list_assets or get_guide, and no prerequisites. The name implies a static reference lookup, but the description leaves that entirely 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 cover the key safety profile (readOnlyHint, idempotentHint, destructiveHint=false, openWorldHint=false). The description adds useful context that storage keys are omitted and variant status is included, but it does not explain pagination behavior despite the cursor parameter.

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 tight sentences with the core purpose front-loaded and no wasted wording. It is appropriately sized for a simple list tool.

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

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

Given zero schema description coverage and no output schema, the description should explain the required appId, the cursor-based pagination behavior, and the shape of returned metadata. It only briefly notes storage-key omission and variant status, leaving important calling details incomplete.

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 0%, so the schema provides no semantic guidance for appId or cursor. The description does not explain either parameter, leaving the agent without information about app scoping or pagination.

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 read action ('Read screenshot/icon metadata and variant status') and clearly identifies the resource. It does not differentiate this tool from related siblings such as list_asset_formats, so it falls short of a 5.

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 no explicit guidance on when to use this tool versus alternatives, and it does not mention prerequisites or exclusions. The use case is only implied by the description.

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=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds useful field-level context by saying file keys and provider logs are omitted, but it does not describe auth needs, pagination behavior, or response shape.

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 short sentences, front-loads the primary action and returned data, and contains no filler. It is appropriately concise, though the second sentence is the only place it adds value beyond the 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?

Annotations cover the safety profile and there is no output schema to explain return values. However, with 0% schema description coverage, the description should compensate for the required appId scope and cursor pagination, and it does not; an agent is left to infer those from parameter names alone.

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 0%, and the description never mentions either parameter. It does not explain that appId scopes the list to an app or that cursor is used for pagination, so it adds no meaning beyond the bare parameter names in 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 gives a specific verb, "Read," and names the resources: uploaded binary metadata, Apple worker progress, and linked release IDs. It aligns with the title "List uploaded builds," but it does not explicitly distinguish this tool from sibling listers such as list_releases or list_assets.

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 that this is for listing uploaded builds, but it gives no explicit when-to-use guidance, no exclusions, and no comparison to alternatives. It also does not mention pagination or any prerequisite beyond what the schema requires.

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 genuinely new behavioral context: the data is a saved draft and may diverge from the live store text, and results are paginated. It stops short of explaining page size or cursor expiry.

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 what is read, then the draft caveat, then pagination. No filler and no repetition of the 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 simple read-only list tool with rich annotations and no output schema, the description is close to sufficient, but it omits how to obtain or use the cursor and what a page contains, which matters given zero schema documentation.

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

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

Schema description coverage is 0%, so the description must explain appId, locale and cursor, but it only alludes to locale and pagination. It never clarifies that cursor is an opaque continuation token or what locale filtering does when omitted, leaving two of three parameters undocumented anywhere.

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 canonical OneStore listing drafts') and scopes it by locale. The clarification that these are saved drafts rather than live store text gives an agent an unambiguous mental model of what is returned.

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 only implied: an agent can infer this is the way to fetch listing drafts, but the description never states when to choose it over siblings, whether a live-text tool exists, or any prerequisites. The draft-vs-live caveat is context, not routing guidance.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so safety is covered. The description adds real value with two caveats: data is 'cached' (may be stale) and a successful call does not imply the release is live. However, 'store review/rollout states' is ambiguous and could be misread as a write, which is not clarified.

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?

It is only two sentences, and the useful caveat is placed last, but the first sentence is garbled enough that brevity does not translate into clarity. The opening verb+resource is front-loaded, which is a point in its favor.

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, no parameter descriptions, and no usage guidance, the description needs to do more work than it does. Pagination behavior, what a release record contains, and the effect of the cache on freshness are all left unstated.

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 0%, so the two parameters (appId, cursor) are documented nowhere. The description does not mention appId as the required scope or explain that cursor is for pagination, leaving the caller to infer both.

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 name and title say 'List releases', and the description opens with 'Read cached releases', but the second half of that clause ('and store review/rollout states') is cryptic and sounds like a mutation rather than a listing. It never states the scope (all releases for an appId?) and gives no hint of how this differs from siblings like list_reviews or check_apple_release.

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

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

There is no statement of when to use this tool, no prerequisites, and no named alternative among the many list_* siblings. The only guidance offered — 'Success of an operation does not mean the release is live' — is a behavioral caveat, not a usage rule.

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). The description adds real context beyond them: results come from a cache, pages are capped at 50, and continuation uses nextCursor. However, the cryptic phrase 'OneStore reply eligibility' is unexplained and no staleness bounds are given for the cache.

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, front-loaded sentences with no filler. The density borders on opacity in the middle sentence, but nothing is wasted.

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?

Six unlabeled parameters, no output schema, and no explanation of what a review record contains or how the date range and appId scoping behave. The description covers paging and one filter caveat but leaves most invocation-relevant detail 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 0%, so the description must carry all six parameters. It only gestures at 'filter' semantics (critical/unanswered eligibility) and pagination via cursor, leaving from/to, appId, and platform completely undefined anywhere.

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 up to 50 cached store reviews per page') and adds the page cap. It is clearly distinct from siblings like list_apps or list_releases, though it never says which store/platform context it operates in.

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?

No statement of when to use this tool versus alternatives, no prerequisites, and no guidance on choosing among the five filter values or the platform enum. Usage is only implied by the verb 'list'.

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