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

No annotations provided, so the description must disclose behavioral traits. It only states the action without revealing if testers are appended or replaced, required permissions, or side effects. This is insufficient for a read-mutation operation.

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 clear and concise sentence, no redundant information. It is appropriately brief for a simple action, though it could include more context without harming conciseness.

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

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

Given no output schema and zero annotations, the description is minimally complete. It states the action but lacks context about prerequisites, effects, or typical use cases. Adequate but not informative.

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

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

Schema coverage is 100% with descriptions for both parameters. The description adds no additional meaning beyond 'betaGroupId' and 'betaTesterIds'. Baseline score of 3 is appropriate since schema already clarifies the parameters.

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

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

The description clearly states 'Add beta testers to a group', specifying the verb and resource. It distinguishes from siblings like apple_remove_beta_testers_from_group, but could be more specific about the type of testers (existing vs. new).

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 guidance on when to use this tool, prerequisites (e.g., testers must exist, group must exist), or alternatives like apple_invite_beta_tester. The description is too minimal for a usage guideline.

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

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

With no annotations, the description carries full burden. It usefully discloses two behavioral traits: no submission occurs (state effect) and retries reconcile an already-attached item (idempotency), plus that assigned assets are reviewed with their owning item. It omits permission requirements, error behavior for mismatched resource types, and what the call returns, leaving meaningful gaps for a mutation tool.

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

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

Three tight sentences, front-loaded with the action and accepted resource types, then the initial-release rule, then the retry guarantee. No filler or restated name.

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 5-parameter mutation with no annotations and no output schema, the description covers purpose, one usage condition, and idempotency but leaves parameter meaning and return/error semantics undocumented. Adequate to start, not complete enough to call confidently.

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 must compensate. It does map the resourceType enum to human meanings (image/video, custom product page version, v2 experiment, app version) and explains when to use appStoreVersions, but says nothing about appId, submissionId, resourceId, or platform, leaving half the 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 ("Attach") and enumerates the exact resource kinds it accepts, plus the target ("a draft"). The phrase "without submitting" implicitly contrasts with the sibling submit_review_submission, so an agent can differentiate 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?

"For an initial app release include the app version" gives a real conditional usage hint, and "without submitting" implies this is a preparation step rather than the submission action. But it never explicitly names alternatives (e.g., use apple_submit_review_submission to submit, apple_create_review_submission to create the draft) or states prerequisites as exclusion rules, so guidance stays implied.

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

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

No annotations are provided, and the description does not disclose behavioral traits like destructive potential, required permissions, or side effects (e.g., replacing an existing assignment). The description carries the full burden but provides minimal transparency.

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

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

The description is a single sentence with no superfluous words. It is appropriately sized for the simple operation it describes.

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 lacks important context such as whether the version must be in a specific state, what happens if the build is already assigned, or what the tool returns. With no output schema, the agent gains no insight into 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% but the descriptions ('App Store Version ID', 'Build ID') are generic. The tool description adds no additional meaning 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?

The description clearly states the action ('assign a build') and the resource ('App Store version'). It distinguishes from siblings which handle listing, creating, or deleting, but does not elaborate on scope or preconditions.

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 guidance on when to use this tool versus alternatives. There is no mention of prerequisites, such as requiring that the version and build exist, or when assignment is appropriate.

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

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

No annotations exist, so the description must carry the full behavioral burden, and it does substantial work: it discloses the mutation mechanism (PATCH with attributes.canceled=true), the target resource, and that the operation is conditional. It stops short of describing failure behavior when the submission is no longer cancellable, or permission/auth requirements.

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 action and precondition are front-loaded in the first sentence, with mechanism following. The third sentence about the legacy endpoint is longer than necessary but earns its place by preventing a wrong-endpoint misconception.

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 tool with no output schema and no annotations, the description covers what is acted upon and how. The remaining gap is outcome semantics — what the agent should expect if cancellation fails — which an agent would want before calling a destructive operation.

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

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

Schema description coverage is 100%, so the single submissionId parameter is already fully documented in the schema. The description's note that submissionId comes from apple_submit_for_review restates the schema text rather than adding new meaning, so the baseline of 3 applies.

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

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

States a specific verb and resource ('Cancel an in-review submission') and names the operation that produces the target resource (apple_submit_for_review). It also distinguishes itself from the legacy appStoreVersionSubmissions DELETE endpoint, which removes ambiguity about which cancellation mechanism applies.

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 'if still possible' and 'in-review submission' communicate preconditions, and it points back to apple_submit_for_review as the source of the ID. It does not explicitly state what to do when cancellation is no longer possible or name sibling alternatives (e.g. apple_respond_to_review), so the routing guidance is clear but not exhaustive.

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

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

No annotations are provided, so the description carries the full behavioral burden for a mutating tool. It only says a declaration is created and does not disclose permission requirements, whether existing declarations are replaced, how omitted boolean fields are treated, or what the response contains.

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 redundant or wasted text. It immediately establishes the core action, resource, and scope.

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

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

This is an 11-parameter mutation tool with low schema description coverage, no annotations, and no output schema. The description is far too thin to compensate for those gaps, leaving the agent without enough context to confidently populate the boolean accessibility fields.

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

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

Schema description coverage is only 18%, and nine boolean parameters have no schema descriptions at all. The tool description mentions only the app and device family at a conceptual level, leaving parameters such as supportsCaptions, supportsVoiceover, and supportsDifferentiateWithoutColorAlone unexplained beyond their names.

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

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

The description states a specific verb (Create), resource (accessibility nutrition label declaration), and scope (app on a specific device family). It is clear what the tool does, though it does not explicitly distinguish itself from sibling tools such as apple_update_accessibility_declaration or apple_list_accessibility_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?

There is no explicit guidance on when to use this tool versus updating, listing, or deleting accessibility declarations. The word 'Create' implies a new declaration, but the description does not mention prerequisites, when not to use it, or which sibling tool handles existing declarations.

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

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

With no annotations, the description carries the disclosure burden and does real work: it signals an asynchronous long-running operation ('the first reports take 1-2 days'), explains the ongoing vs one-time semantics of accessType, and warns of a uniqueness limit per access type. It omits auth/permission requirements and what response or error a duplicate request yields.

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 compact sentences: purpose first, then the enum effect, then the latency and rate constraint. Nothing is redundant and no sentence could be dropped without losing 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 an unannotated, no-output-schema creation tool the description covers what is created, the time-to-first-data, and the per-access-type limit. It stops short of describing the ONE_TIME_SNAPSHOT mode and the follow-up step of listing/polling the created request.

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 must fully compensate; it explains only ONGOING ('keeps producing daily data') and leaves ONE_TIME_SNAPSHOT's behavior and appId unaddressed. Helpful but partial for a two-parameter tool.

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 ('Ask Apple to start generating App Analytics reports') and enumerates the metrics produced, which immediately separates it from sibling readers such as apple_list_analytics_report_requests and apple_download_analytics_report. An agent can identify 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?

Use is implied ('Ask Apple to start generating...') and the constraint 'Only one request per access type is allowed' hints that existing requests should be checked first, but the description never names the enabling siblings or states when not to call it. A reader must infer the workflow from the existence of apple_list_analytics_report_requests.

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

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

No annotations are provided, so the description carries the full burden. It discloses one real behavioral fact — that this is the initial creation step, implying a precondition that availability does not already exist — but says nothing about permissions, conflict/error behavior, or whether existing settings are overwritten.

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 compact sentence with the action front-loaded and the actionable recommendation appended. No waste, though the two clauses could be split for faster scanning.

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 3-parameter mutation with nested territory objects and no annotations or output schema, the description covers what it does and one recommended configuration but omits failure modes and the relationship to the territory-update sibling. There is a nested array of objects with fields (releaseDate, availableInNewTerritories) whose purpose is left unaddressed.

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 67%, so the schema documents territoryId and the territories array but leaves available, preOrderEnabled, and availableInNewTerritories bare. The description adds genuine semantics by explaining what available/preOrderEnabled combination corresponds to a normal release, which the schema defaults alone do not convey.

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 plus resource ('Create initial app availability') and the scope ('explicit territory settings'). The word 'initial' implicitly distinguishes it from the sibling mutation apple_update_territory_availability and the reader apple_list_availability, though it never names 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 gives one concrete usage recipe ('use available=true and preOrderEnabled=false for a normal release'), which tells the agent how to handle the common case. It stops short of saying when to use this versus apple_update_territory_availability, or what to do if availability already exists.

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

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

No annotations are provided, so the description carries the full burden, yet it only implies a mutating create. It does not cover permissions, whether the group is immediately usable, defaults for feedbackEnabled/hasAccessToAllBuilds, or what is returned.

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 four-word sentence is technically concise but is under-specification rather than efficient communication; it spends no words on the required appId/name or the five optional configuration flags.

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 7-parameter mutation with no annotations and no output schema, the description is far too thin. An agent cannot learn from it what a beta group is in TestFlight terms or how the optional flags affect tester behavior.

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 all 7 parameters are documented in the schema, so the baseline of 3 applies. The description adds no meaning beyond the schema, such as which options are mutually exclusive or typical default choices.

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 verb and resource (create a beta group), so the basic action is identifiable. But it is essentially a restatement of the tool name and offers no scope or differentiation from siblings such as apple_list_beta_groups, apple_delete_beta_group, or apple_add_beta_testers_to_group.

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 guidance on when to create a beta group versus adding testers to an existing one, no prerequisites (an appId is required), and no mention of alternatives among the many sibling tools.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only restates the obvious action without mentioning idempotency, duplicate handling, required permissions, or side effects. The lack of depth fails to inform the agent of important behaviors.

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, concise sentence at the front. It is efficiently short, though it sacrifices necessary detail. It meets the standard for brevity but lacks substantive content to earn a 5.

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 has three required parameters, no output schema, and no annotations, the description is insufficient. It does not explain uniqueness constraints, failure behaviors, or return values. The minimal text leaves the agent underinformed for a registration operation.

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

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

The input schema already describes two of three parameters (identifier and name), and the description adds no additional meaning. The 'platform' parameter has an enum but no explanation of its implications. The description does not compensate for the schema's limited 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 'Register a new bundle ID' uses a specific verb and resource, clearly distinguishing this tool from siblings like 'apple_list_bundle_ids' (list) or 'apple_create_certificate' (different resource). The action is unambiguous and directly maps to its purpose.

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

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

The description provides no guidance on when to use this tool over alternatives, nor does it mention prerequisites, constraints, or cases where the tool should not be used. The agent receives no contextual information to decide between this and similar creation tools.

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

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

With no annotations, the description must disclose behavioral traits. It only says 'Create a certificate' without mentioning required permissions, irreversible actions, rate limits, or that it generates a certificate from a CSR. This is insufficient for safe invocation.

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 extremely concise (three words) but lacks structure. It is front-loaded but too sparse to be informative; the single phrase does not earn its place as it merely restates the tool name.

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

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

Given the tool's complexity (creating a certificate from CSR with specific types), the description is severely incomplete. It does not explain the process, output, or potential errors, and there is no output schema to compensate.

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 has 100% coverage with descriptions for both parameters (csrContent and certificateType). The description adds no additional semantic value, meeting the baseline for schema-rich tools.

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 'Create a certificate' clearly states a specific verb and resource, distinguishing it from other creation tools like apple_create_beta_group or apple_create_iap. However, it lacks context about the platform (Apple Developer) and does not elaborate on the type of certificate beyond what the schema provides.

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 guidance is provided on when to use this tool versus alternatives (e.g., apple_create_profile). The description does not mention prerequisites, caveats, or scenarios where this tool is appropriate.

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

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

With no annotations, the description carries the full burden. It discloses the useful atomic behavior (page + first version + localizations created together) and that copying is optional. It does not state the resulting state of the page (draft vs. live), permission requirements, or failure behavior for a mutation that creates several resources.

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

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

Three short sentences, each earning its place: purpose, optional behavior, follow-up workflow. The core capability is front-loaded with zero preamble.

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 multi-resource mutation with no annotations and no output schema, the description covers what gets created, the optional copy sources, and the follow-up path. It omits the resulting page state, permissions, and what the caller gets back, which an agent would want before invoking.

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 50%: deepLink, locale, and both template params are documented in the schema. The description adds meaning for the two template IDs by framing them as an optional copy source. But the required name and appId parameters are undocumented in both places, so it only partially compensates.

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 (create) and resource (custom product page) plus the key scope detail that it also creates the first version and localizations in one request. That 'in one request' phrasing implicitly separates it from the granular sibling tools like apple_create_custom_product_page_version and apple_create_custom_product_page_localization. It isn't explicit about sibling distinction, keeping it at 4.

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?

Explains the conditional use of the template parameters ('optionally copy screenshots and text from an App Store version or another custom page') and gives a workflow pointer ('add visuals afterwards with the Asset Library placement tools'). It lacks an explicit 'use this instead of X when...' exclusion, but the context 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the 'editable' precondition, which is useful, but it does not explain mutation effects, permissions, error cases, or what happens to existing localizations.

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 definition is a single front-loaded sentence with no wasted wording. It is appropriately concise for the core operation, even though it is sparse overall.

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

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

For a mutation tool with no annotations, no output schema, and incomplete parameter documentation, the description is too thin. It does not give enough context about return behavior, required version state beyond 'editable', or how this differs from updating an existing localization.

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 only 33%: locale is documented in the schema, but versionId and promotionalText are not. The description adds some meaning to versionId by implying it must identify an editable version, but it says nothing about promotionalText and does not compensate for the low 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 states a specific verb ('Add') and resource ('locale to an editable custom product page version'), making the operation clear. It does not explicitly contrast with sibling tools such as update_custom_product_page_localization or delete_custom_product_page_localization, so sibling differentiation is left implicit.

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 'editable custom product page version' and the create-style verb, but there is no explicit when-to-use guidance or comparison to update/delete/list localization tools. An agent can infer the basic scenario but is not told prerequisites or alternatives.

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

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

No annotations are provided, so the description carries the full burden. It does convey the resulting state ('new editable version'), but says nothing about whether existing content is copied, whether a prior draft blocks creation, permission requirements, or side effects on the live approved version.

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. It is efficient, though its brevity is also the source of the missing detail rather than a deliberate trade-off.

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

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

For a mutation tool with no annotations, no output schema, and 0% parameter coverage, the description does too little. An agent cannot tell what the call returns (presumably a new version ID), how to use deepLink, or what to do next after the version is created.

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 mentions neither parameter. 'pageId' is at least inferable from 'custom product page', but 'deepLink' (a URI-formatted string) is completely unexplained — its purpose, format, and whether it is optional are left entirely to guesswork.

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 ('Start a new editable version') against a specific resource ('an approved custom product page'), so an agent knows this creates a new draft version rather than modifying an existing one. It does not explicitly name sibling tools like apple_update_custom_product_page_version or apple_create_custom_product_page, so differentiation is left to inference.

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?

'of an approved custom product page' implies the precondition that a page must already be approved before a new version can be started, which is useful context. However, it never states when to choose this over apple_update_custom_product_page_version or apple_create_custom_product_page, nor what to do when a draft version already exists.

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

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

No annotations are provided, so the description must carry the full behavioral burden. It explains traffic routing but omits mutation-related context such as permissions, required setup, experiment lifecycle, or whether creation is reversible.

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 definition is two tight sentences. It is front-loaded with the action and uses the second sentence efficiently to explain the most distinctive parameter.

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 create tool with no annotations and no output schema, the description is too thin. It covers trafficProportion but leaves the other three parameters, including required appId and name, undocumented.

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% across four parameters. The description adds useful meaning for trafficProportion but says nothing about appId, name, platform, or the 1-100 range 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 states a specific verb and resource: create a product page optimization test. It distinguishes creation from sibling experiment operations like list, get, update, and delete, though it does not use the exact term 'experiment'.

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 says what the tool creates but gives no guidance on when to use it versus alternatives, prerequisites, or constraints. There is only an implied 'use this to create' message.

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

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

No annotations are provided, so the description carries the full burden. It confirms this is a creation/mutation but says nothing about required permissions, whether the experiment must be in a particular state, or what side effects occur. Only the appIconName detail adds behavioral value.

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 core action front-loaded; the second sentence is a useful, non-redundant clarification of one parameter. Nothing is 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?

A mutation tool with no annotations, no output schema, and three undocumented-in-schema parameters needs far more: what gets created, what the response contains, and what name/experimentId mean. The definition is under-specified for the complexity.

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

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

Schema description coverage is 0% across three parameters, yet the description only explains appIconName. The 'name' parameter (presumably the treatment name) and 'experimentId' are left entirely undocumented, so the description compensates for only a third of the gap.

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 ('Add a treatment (variant) to a test') and parenthetically disambiguates the domain term 'treatment' as 'variant'. It doesn't distinguish itself from siblings like apple_update_experiment_treatment or apple_create_experiment, but the create semantic is clear.

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 guidance on when to use this versus apple_update_experiment_treatment or apple_create_experiment, and no prerequisites such as an existing experiment being required. The agent must infer usage purely from the verb.

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

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

No behavioral traits disclosed beyond the basic action. For a creation tool, one might expect information about side effects, idempotency, or required permissions. With no annotations, the description fails to provide this context.

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

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

The description is a single, direct sentence with no fluff. It is concise but could be slightly expanded without losing efficiency.

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 has 4 required parameters, an enum, and no output schema, the description is too sparse. It doesn't mention what happens after creation (e.g., return value, confirmation) or any constraints.

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

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

Schema coverage is 100%, so baseline is 3. The description adds no additional meaning to parameters; it simply restates the action. No extra semantics beyond schema.

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

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

The description clearly states the action and resource: 'Create an in-app purchase'. It distinguishes from sibling tools like apple_delete_iap or apple_get_iap by specifying 'create'. However, it lacks context specific to Apple's environment.

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 guidance on when to use this tool versus alternatives (e.g., google_create_iap) or under what conditions. No mention of prerequisites or prohibitions.

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

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

With no annotations, the description must carry the full behavior burden. It usefully discloses the ordering dependency on price points, but says nothing about whether the created codes are active immediately, whether the operation is reversible, what permissions are needed, or what the call 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 sentences, no waste, and the product-type restriction is front-loaded before the prerequisite. Every clause earns its place.

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

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

For a mutation tool with no annotations and no output schema, the definition covers the key dependency but leaves the agent without a picture of result behavior, permissions, or irreversibility of a created offer code. Adequate but with real gaps.

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

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

Schema description coverage is 100%, so name, iapId, prices and customerEligibilities are already documented in the schema, including the pricePointId cross-reference. The description only reinforces the price lookup hint already present, adding no new parameter meaning.

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

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

States a specific verb and resource ('Create an offer code') and bounds the scope to three IAP kinds, which implicitly separates it from the sibling apple_create_subscription_offer_code. An agent can pick the right creator without opening any 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 prerequisite: per-territory prices must be looked up first via apple_get_iap_price_points, naming the alternative tool. It does not explicitly say to use apple_create_subscription_offer_code when the product is a subscription, but the scoping sentence carries that meaning implicitly.

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

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

With no annotations, the description carries the full burden: it does disclose the first-version restriction, a real behavioral trait. However, it says nothing about idempotency, what happens if a phased release already exists, permission requirements, or that the default state is INACTIVE (i.e. that the call may not actually 'enable' anything without the state 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?

A single compact sentence with the action front-loaded and the restriction appended; 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 mutation tool with no annotations, no output schema, and an undocumented parameter, the description is too thin. It does not explain how to actually activate the release or what the response represents.

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 only 50% and the description never mentions the `state` parameter at all, leaving the agent to infer from the enum alone. Worse, `state` defaults to INACTIVE while the description promises to 'enable' a release, a tension the description should resolve but does not.

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 ('Enable a seven-day phased release'), which clearly separates it from the readable/mutable siblings apple_get_phased_release, apple_update_phased_release and apple_delete_phased_release. It does not name those siblings explicitly, 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 a concrete precondition for non-use ('unavailable for an app's first version'), which is genuinely useful routing guidance. It never mentions the alternative of apple_update_phased_release when a phased release already exists, so 'when-not' is covered but 'alternatives' is not.

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

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

With no annotations, the description carries the full burden but does disclose meaningful behavior: it implicitly requires the asset to be uploaded/ready and it is idempotent because it reuses an existing identical placement. It does not cover permissions, what happens on conflicting placements, or what the call returns (no output schema), leaving notable gaps for a mutation tool.

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

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

Two sentences, zero filler, with the core action front-loaded and the prerequisite (apple_get_asset_specs) plus idempotency note following. Every clause carries information an agent needs.

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 6-parameter mutation tool with no annotations, no output schema, and 0% schema coverage, the description covers the main workflow but omits the mediaType and targetType dimensions and says nothing about the returned placement identifier that sibling tools like apple_reorder_placements or apple_delete_placement would need.

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. It correctly explains where placementType and placementGroup values come from and implies localizationId must be editable, but mediaType, targetType (defaulting to appStoreVersionLocalizations), and the string format of assetId/localizationId are never addressed.

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: place a ready library asset onto an editable localization. It references the sibling that supplies inputs (apple_get_asset_specs) and distinguishes itself from listing siblings by the 'place' verb. It does not explicitly contrast with apple_delete_placement or apple_reorder_placements, but the action is 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?

Gives a clear prerequisite chain: placementType and placementGroup must come from apple_get_asset_specs, and the asset must already be a 'ready' library asset. It also notes reuse of identical placements. No explicit when-not-to-use or alternative routing is provided, which keeps it below a 5.

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

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

With no annotations provided, the description carries full responsibility for disclosing behavioral traits. It only states the action without mentioning side effects, authorization needs, or any constraints beyond the schema. Mutations like profile creation typically involve dependencies and potential errors, which are not addressed.

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 very short and concise, consisting of a single sentence. It is front-loaded with the action. However, given the complexity and importance of profile creation, a slightly more detailed description would be justified without becoming verbose.

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

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

Given there is no output schema, the description should explain what is returned upon creation (e.g., profile ID, profile object). It also does not clarify conditional requirements (e.g., deviceIds needed for development profiles) or the relationship with other resources. The description is incomplete for a user to fully understand the tool's behavior.

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

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

The input schema has 100% description coverage, so the baseline is 3. The description adds no additional meaning to the parameters beyond what the schema already provides. The schema itself has clear descriptions for each parameter.

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 and resource ('Create a provisioning profile'). It effectively distinguishes from siblings like 'apple_delete_profile' and 'apple_list_profiles'. However, it could be more specific about the scope (e.g., iOS, macOS) but the 'profileType' parameter covers this.

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 guidance is provided on when to use this tool vs alternatives. There is no mention of prerequisites (e.g., needing certificates, bundle IDs, or devices) or conditions under which the tool should or should not be used.

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

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

With no annotations, the description carries the burden and does disclose two important traits: the call creates an empty draft (no submission side effect) and it will not replace an existing draft. It omits return shape (draft ID/state), permissions, and any failure modes for conflicting drafts, so the disclosure is good but not 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 clauses, with the verb and the non-submission caveat front-loaded. The middle fragment ("For asset-only, custom product page or product page optimization review") is terse to the point of being slightly opaque, but nothing is 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?

For a workflow entry point with no output schema and no annotations, the description should hint at what comes next (add items, then submit) and what the created draft returns. It covers the creation semantics but leaves the surrounding lifecycle implicit.

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

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

Schema description coverage is 0% for both parameters, so the description must compensate and it says nothing about appId or the platform enum (IOS default vs MAC_OS/TV_OS/VISION_OS). The review-type sentence hints at scope but never maps to a parameter.

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 ("Create an empty review draft") plus an explicit non-goal ("does not submit it"), which separates it from apple_submit_review_submission. It stops short of naming the sibling tools, so the differentiation is implicit rather than spelled out.

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 clear selection rule for use: asset-only, custom product page, or product page optimization review types. It also warns that existing drafts must be resumed rather than replaced, but never names which tool performs the resume, leaving the agent to hunt through apple_list_review_submissions / apple_get_review_submission.

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

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

With no annotations, the description carries the burden itself; it does disclose the critical behavioral trait that the endpoint is deprecated by Apple, which is valuable beyond anything structured. However, it says nothing about prerequisites (auth/scopes), whether the operation is reversible, or what a successful call yields for a mutating legacy endpoint.

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, zero redundancy, with the deprecation warning and preferred alternatives front-loaded. Every clause earns its place.

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

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

For a simple two-parameter, non-nested mutation with full schema coverage, the description covers purpose, status, and replacement path. It leaves out what a screenshot set contains and any failure/permission expectations, which is a minor gap but not one that blocks a correct call.

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

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

Schema description coverage is 100% with both required parameters documented, including displayType examples, so the schema does the heavy lifting. The description only alludes to display-type scoping and adds no format or constraint detail beyond the schema, meeting the baseline 3.

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

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

States a specific verb and resource ('create a screenshot set') scoped to 'a specific display type', and explicitly separates itself from the modern path by naming apple_upload_asset and apple_create_placement. An agent can identify the tool and its status 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?

Explicitly flags the tool as legacy and directs the agent to two named alternatives with the implied condition (prefer the new asset/placement flow). This is exactly the when-to-use guidance an agent needs to avoid a deprecated path.

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

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

With no annotations, the description must disclose behavioral traits. It states 'create' implying mutation, but does not mention idempotency, irreversible effects, required permissions, or what happens if the group already exists. Lacks transparency for a creation operation.

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

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

The description is a single sentence, but it is too brief and does not earn its place. It sacrifices completeness for brevity, lacking valuable details that could be added without significant verbosity.

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

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

Given the simplicity of the tool (2 parameters, no output schema), the description is minimal. It does not explain what a subscription group is, how referenceName is used, or any constraints. Incomplete for a new user unfamiliar with App Store Connect.

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

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

Schema coverage is 100% with descriptions for both parameters ('App ID', 'Reference name'). The tool description adds no additional meaning beyond the schema. Baseline of 3 is appropriate since the schema already provides the meaning.

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

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

The description 'Create a subscription group' uses a specific verb and resource, clearly indicating creation of a subscription group. It distinguishes from sibling tools like delete and list. However, it could be more explicit about what a subscription group is in the context of Apple App Store Connect.

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 guidance on when to use this tool versus alternatives. It does not mention prerequisites such as needing an existing app (appId) or that groups are used for auto-renewable subscriptions. No exclusions or context provided.

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

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

With no annotations, the description carries the full behavioral burden and only discloses the price-lookup dependency and external distribution. It says nothing about required App Store Connect permissions/roles, whether codes are immediately live, whether they can be revoked or expire, or that creation is a non-reversible write.

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 actionable content: what it makes, and the mandatory lookup step before calling. 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 nine-parameter, eight-required mutation with no annotations and no output schema, the description covers the main trap (price points) but leaves the offerEligibility/offerMode interaction and post-creation behavior unexplained. Adequate to start, not complete enough to call confidently.

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 all nine parameters including the three enums are already documented. The description only adds that prices are 'per-territory' and must come from the price-points tool, which is a helpful cross-reference but nothing the schema lacks.

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 and resource ('Create a subscription offer code') with clarifying parenthetical that these are custom/one-time-use codes distributed outside the App Store. It does not explicitly distinguish itself from the near-sibling apple_create_iap_offer_code, which an agent scanning a long tool list would likely confuse it with.

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 a concrete prerequisite ('look them up first with apple_get_subscription_price_points'), naming the exact sibling tool and ordering, which prevents a likely failure. It gives no exclusion conditions, however (e.g., when to use apple_create_iap_offer_code instead).

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses little beyond the mutation itself. It does not say what happens if the locale already exists, whether the call is idempotent, what permissions are needed, or what is created/returned.

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 that states the action first and the payoff second, with no filler. Its brevity is a virtue for structure but contributes to the disclosure gaps elsewhere.

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

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

For a mutation tool with no annotations, no output schema, and an undocumented required ID parameter, the description is too thin. An agent cannot tell from it what a successful call produces or how to handle an already-localized treatment.

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 only 50%: 'locale' is documented in the schema, but 'treatmentId' has no description anywhere. The phrase 'to a treatment' only loosely hints at treatmentId and adds no format, sourcing, or lookup guidance for either parameter.

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: 'Add a locale to a treatment'. The sibling set contains list/delete treatment localizations and custom-product-page localization tools, and the name plus description make this one distinguishable, though the description itself does not name the alternatives.

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 purpose clause ('so it can get its own screenshots and visuals') implies why you would do this, but there is no guidance on prerequisites (treatment must already exist), duplicate-locale behavior, or when to use the custom-product-page localization variant instead.

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

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

No annotations are provided, so the description has to carry the full behavioral burden. It states that this is a mutation, but says nothing about required permissions, whether the new version starts in an editable state, how releaseType affects behavior, or what happens after creation. That is a real gap for a write tool with no 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 one short, front-loaded sentence that says what the tool does without extra words. But it is terse to the point of under-specification rather than being concise and complete.

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

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

This is a mutation tool with 6 parameters, 2 enums, no annotations, no output schema, and only 50% schema coverage. The description doesn't cover required fields, platform defaults, release scheduling semantics, or the result of the call, so an agent would have to infer most of the calling contract.

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 only 50%. The description doesn't define versionString, platform, releaseType, earliestReleaseDate, or copyright, and it doesn't explain the interplay between releaseType=SCHEDULED and earliestReleaseDate. Three parameters have no description anywhere, so the description should compensate but doesn't.

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: 'Create a new App Store version.' This clearly distinguishes it from siblings like apple_create_version_localization or apple_create_custom_product_page_version, which operate on sub-resources rather than the top-level version. It just doesn't say how to differentiate further.

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 guidance is given about when to use this tool versus alternatives. It doesn't say to check apple_list_versions first, nor to use apple_update_version for existing versions, nor what prerequisites must be met before creating a version.

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

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

With no annotations, the description should disclose behavioral traits like mutation, required permissions, or side effects. It only states 'create' without elaboration on what happens to existing data or error conditions.

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 very concise at one sentence, front-loading the key action. While it lacks detail, it avoids redundancy and is easy to scan.

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

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

Given the complexity (8 parameters, no output schema, no annotations), the description is insufficient. It does not explain the purpose of localization, expected return values, or how to structure multiple optional fields.

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

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

Schema description coverage is low (38%), requiring the description to add meaning. However, it does not explain how parameters like 'description', 'whatsNew', or 'promotionalText' are used together, nor does it clarify the format of 'locale' beyond what the schema provides.

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

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

The description clearly states the verb 'Create' and the resource 'localization for a version', distinguishing it from sibling tools like 'apple_update_version_localization' and 'apple_list_version_localizations'.

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 guidance is provided on when to use this tool versus alternatives such as updating or listing localizations. The description lacks context on prerequisites (e.g., version must exist) and excludes any when-to-use advice.

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

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

No annotations are provided, so the description carries the full behavioral burden for a destructive operation. It does not say whether the deletion is permanent, what happens to declarations referenced by a live app version, or what permissions are required — all of which matter for an irreversible mutation.

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 short, front-loaded sentence with no filler. It is efficient, though its brevity is partly the reason behavioral details are absent.

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

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

For an unannotated destructive tool with no output schema, the description should at minimum state irreversibility and the expected result. It says nothing about consequences or return behavior, leaving the agent to guess.

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

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

With a single parameter at 100% schema coverage, the schema already documents declarationId fully. The description adds no format hints (e.g., where the ID comes from or whether it is the numeric or opaque identifier), 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?

The description states a specific verb (Delete) and resource (an accessibility nutrition label declaration), which pairs cleanly with the list/create/update siblings in the same family. It is clear what the tool does, though it relies on the naming convention rather than an explicit contrast with 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?

There is no guidance on when to delete versus updating the declaration via apple_update_accessibility_declaration, nor any prerequisites such as app/version scoping or whether the declaration must be detached first. The agent must infer all of this from the verb alone.

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

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

With no annotations, the description carries the full behavioral burden but does disclose the single most important trait: the tool fails rather than cascades when localizations reference the asset. It omits whether deletion is irreversible, required permissions, and what a failure returns, so it is strong but not 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?

Two short sentences, zero filler; the scope constraint and the refusal precondition are both front-loaded before any remedy is mentioned.

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 two-parameter destructive tool with no output schema, the description supplies the critical dependency rule an agent must know before calling. Missing only peripheral details like auth requirements and response shape on failure.

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. 'image or video' maps onto the mediaType enum, and 'from the library' implies assetId, but neither parameter is described by name or format, so meaning is only partially added.

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 ('Delete an ... image or video from the library') and narrows the scope with 'unplaced', which separates it from apple_delete_placement and apple_delete_screenshot. It doesn't name a sibling outright, but the constraint is precise enough to identify the operation.

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

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

Explicitly gives the precondition that selects success vs. refusal ('Refuses to delete if any localization still uses it') and names the prerequisite action ('delete the intended placements first'). That's concrete when-to-use guidance; only the exclusion of an alternative deletion tool is left implicit.

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

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

With no annotations, the description must bear full burden. It only states the action (delete) but omits details like irreversibility, cascading effects, or required permissions, which are important for an agent.

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

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

The description is a single sentence with no wasted words, front-loading the key action. It is appropriately concise for a simple 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 the lack of output schema and annotations, the description should provide more context about the operation's effects. It is too minimal for a delete tool that likely has irreversible consequences.

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

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

Schema coverage is 100% with a clear 'Beta Group ID' description. The tool description adds no additional meaning beyond the schema, so the baseline of 3 is appropriate.

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

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

The description uses a specific verb (delete) and resource (beta group), clearly distinguishing it from sibling tools like apple_create_beta_group or apple_list_beta_groups.

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 no guidance on when to use this tool, what prerequisites are needed, or what alternatives exist. For a destructive operation, such context is critical.

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

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

No annotations are available, so the description must convey behavioral traits. It only states 'delete', implying a destructive action, but does not disclose if it is permanent, what cascading effects occur, or required permissions.

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 extremely concise (4 words). While not verbose, it is too brief to provide adequate context. It is appropriately sized for a simple tool but lacks structure.

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

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

Given the simple tool with one parameter and no output schema, the description should cover consequences, permissions, and error conditions. It only states the action, leaving significant gaps in understanding.

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

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

Schema coverage is 100% with the parameter having a description. The description adds no additional meaning beyond 'Beta Tester ID'. For a single parameter, the baseline is 3.

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

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

The description 'Delete a beta tester' clearly states the action and resource. It distinguishes from sibling tools like 'apple_invite_beta_tester' or 'apple_list_beta_testers'. However, it lacks additional context about scope or side effects.

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 guidance is provided on when to use this tool versus alternatives. There is no mention of prerequisites, circumstances under which deletion is allowed, or consequences.

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

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

No annotations, so the description carries the full disclosure burden. It usefully flags the state gate that will block or error on PROCESSING/COMPLETE uploads, but says nothing about whether the discard is irreversible, what error surfaces if the state is wrong, or what permissions are needed for a destructive mutation.

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 sentence with zero filler; the destructive action and its state restriction come first, and the exclusion clause follows. Everything earns its place.

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

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

For a one-parameter destructive tool with no annotations, the description covers the critical usage constraint and prerequisite. It stops short of noting irreversibility or post-delete state, which is the main remaining gap for a mutation with no annotation safety net.

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 and schema coverage is 100%, with the schema already describing buildUploadId as the 'Build Upload ID to discard'. The description adds no format, ID-source, or lookup guidance beyond that, 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 (discard) and resource (Build Upload) and constrains it to two named states, AWAITING_UPLOAD and FAILED. That state scoping separates it cleanly from sibling tools like apple_upload_build and apple_wait_for_build_upload without needing 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?

Explicitly names the prerequisite check (apple_get_build_upload) and carves out the exclusion cases: do not use for PROCESSING or COMPLETE uploads. Both the when and the when-not are 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?

No annotations are provided, so the description carries the full behavioral burden. It usefully states that the page URL stops working in campaigns, but does not disclose irreversibility, permission requirements, or what happens to associated localizations and campaign references.

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 words. The consequence is appended efficiently via a semicolon.

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 destructive tool with no annotations, no output schema, and an undocumented parameter, the description is too thin. It covers the basic consequence but omits irreversibility, side effects on localizations, and any confirmation or prerequisite context.

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

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

The schema has one required parameter, pageId, with 0% description coverage, and the description never mentions it. The single sentence implies the target is the page, but adds no format, source, or identifier guidance beyond what the schema already provides.

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: deleting a custom product page. It is distinguishable from sibling update/get/list custom product page tools, though it does not explicitly distinguish itself from deletion tools for related resources such as localizations.

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 name and description: use this to remove a custom product page. There is no explicit guidance on when not to use it, prerequisites, or how it differs from related deletion tools.

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

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

With no annotations, the description carries the full behavioral burden, and it does not say whether the removal is permanent, what happens to translated content, what permissions are required, or what the response contains. The only real signal is the mildly implied 'editable' state constraint.

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 or repetition. Its brevity is efficient, though the terse phrasing leaves little room for the missing behavioral and parameter detail.

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 destructive single-parameter tool with no annotations and no output schema, the definition omits too much. It does not explain ID provenance, irreversibility, or the editable-version prerequisite.

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 single parameter localizationId has 0% schema description coverage, so the description must compensate. It only says 'a locale,' which does not explain that the parameter is an opaque identifier or how to obtain it via apple_list_custom_product_page_localizations before deleting.

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: 'Remove a locale from an editable custom product page version.' That clearly separates it from apple_delete_custom_product_page and apple_delete_treatment_localization. It stops short of naming those siblings or noting that the target is a localization record rather than just a locale string.

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 word 'editable' hints that the parent version must be in an editable state, but no explicit precondition is stated. There is no guidance on when to delete versus update a localization, and no alternative tool is named.

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

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

No annotations are provided, so the description carries the full burden. It does disclose one meaningful behavioral constraint — the test must not have run — but omits irreversibility, required permissions/roles, and the failure mode when the precondition is violated, which are the traits that matter most 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?

A single front-loaded sentence with no filler; the resource and the constraint arrive in one pass. It is efficient, though its brevity is partly the source of the gaps in other dimensions.

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 destructive, non-annotated tool with no output schema and an undocumented parameter, this is thin. An agent lacks irreversibility guidance, the error behavior for a running test, and any pointer on ID provenance — the definition does not give enough to invoke it safely with confidence.

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 the single required parameter experimentId, and the description says nothing about it — no format, no indication of where to obtain the ID (e.g., from apple_list_experiments). With one undocumented parameter the description does not compensate for the coverage gap.

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 (delete) and resource (product page optimization test / experiment), which lets an agent distinguish it from adjacent siblings such as apple_delete_experiment_treatment and apple_delete_custom_product_page. It stops short of explicitly naming those siblings, but the resource is precise enough to identify the target unambiguously.

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 'that has not run' gives an implicit precondition that narrows when this is legal, but the description never says what to do instead for a test that has run (e.g., use apple_update_experiment to stop it) and names no alternatives. Usage is inferable but not 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?

No annotations are provided, so the description carries the full behavioral burden. It discloses that this is a deletion and that the test must not have started, but it omits irreversibility, permissions, and effects on related treatment localizations or other resources.

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 one front-loaded sentence with no unnecessary wording. Every word contributes to stating the action and its main precondition.

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 destructive delete tool with no annotations, no output schema, and an undocumented required parameter, the description is too sparse. It gives the core action and precondition but lacks safety, permission, and parameter guidance needed for reliable 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?

The schema has 0% description coverage for the single required parameter, treatmentId. The description only implies that a treatment is being deleted and adds no format, source, or validation details for the parameter beyond what the schema name and type already convey.

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: delete a treatment from a test. It also distinguishes this from deleting an experiment and from treatment creation/update via the 'not started' scope, but it does not explicitly name sibling alternatives.

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 'that has not started' gives an implied precondition for when deletion is valid. However, the description does not explain how to find the treatmentId, what to do if the test has started, or when to use this tool versus updating or deleting the experiment.

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 indicates a destructive action ('Delete') but fails to disclose behavioral traits such as irreversibility, side effects (e.g., affecting related resources like pricing), or required permissions. With no annotations provided, this gap is significant.

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 very concise with a single sentence, but it may be too minimal. While it avoids excess, it misses opportunities to add value in other dimensions.

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

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

Given the absence of annotations and output schema, the description is incomplete. It does not clarify return values, confirmation messages, or error scenarios, leaving the agent unsure about the outcome of the operation.

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

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

While schema description coverage is 100%, the description adds no meaning beyond the schema's own description of 'iapId'. It does not clarify the format, origin, or validation constraints for the parameter.

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 'Delete' and the resource 'in-app purchase', which is a specific verb+resource combination. While it does not differentiate from sibling tools that delete other entities, the resource name is distinct enough given the context.

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 usage guidelines are provided. The description does not mention when to use this tool versus alternatives like apple_get_iap or apple_list_iap, nor does it specify prerequisites such as the need for the in-app purchase to exist.

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

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

With no annotations at all, the description must carry the full behavioral load. It discloses the key state constraint (must not have started) but says nothing about irreversibility, required App Store Connect permissions, or what happens to the parent version after cancellation — significant gaps for a destructive operation.

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, front-loaded with the verb/resource and then the constraint. Zero padding.

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 tool this covers the essentials of what and when, but with no annotations and no output schema the description should at least mention irreversibility or post-cancel behavior; those omissions leave it only minimally adequate.

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 parameter is already documented as an "Inactive App Store Version Phased Release ID". The description adds no format, sourcing, or lookup guidance beyond the precondition already implied by 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 (Cancel) plus the resource (a phased release configuration) and the state precondition. It is distinguishable from apple_update_phased_release / apple_create_phased_release by name and by the cancellation framing, though it does not explicitly name a sibling.

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?

"before the phased release has started" is an explicit precondition that gates usage and implicitly routes post-start cases to apple_update_phased_release. No alternative tool is named outright, so it stops short of a full 5.

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

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

With no annotations, the description carries the full burden, and it does disclose the key blast radius: only the placement goes away, the reusable asset and other placements survive. It does not say whether the removal is reversible, what permissions are required, or what happens to a localization left with zero placements.

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 sentence with the action front-loaded and the most important safety fact (asset survives) trailing immediately. No filler, nothing redundant.

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 destructive tool with no annotations and no output schema, the description covers intent and blast radius but omits confirmation of irreversibility, auth requirements, and return behavior. Adequate but with clear gaps for a delete operation.

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

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

Schema description coverage is 0% and there is one required parameter, placementId, which the description never mentions. The only help is the word "localization," hinting the placement lives under a localization, but nothing explains the identifier's format or where to obtain it.

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

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

States a specific verb+resource pair ("Remove a placement from its localization") and immediately delimits scope by saying the library asset and its other placements are untouched, which separates it from apple_delete_asset. It does not name the sibling it differs from explicitly, so it falls just 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?

Usage is only implied: the reader can infer this is the right tool when the intent is to detach a placement from one localization rather than delete the asset, and that apple_delete_asset covers the latter. There is no explicit when-to-use statement, no prerequisites, and no mention of alternatives by 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?

No annotations provided, so the description must fully explain behavior. It only mentions deletion without specifying if it's irreversible, what happens to associated entities, or any side effects.

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

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

Single sentence with no redundant information; very concise and to the point.

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 1 parameter and no output schema, the description is minimal. While it conveys the basic action, it lacks context about deletion behavior, making it adequate but not complete.

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

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

Schema already covers 100% of parameters with 'Profile ID' for profileId. The description adds no additional meaning beyond what the schema provides; 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 'Delete a provisioning profile' clearly states the action (delete) and the resource (provisioning profile), distinguishing it from siblings like apple_create_profile and apple_list_profiles.

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 guidance on when to use this tool, prerequisites (e.g., profile existence), or when not to use it. Lacks context about dependencies or alternative tools.

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

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

With no annotations, the description carries the full burden; it usefully discloses that this targets a deprecated API and names replacements, but never states that the deletion is permanent, what permissions are needed, or whether anything else is affected.

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, the legacy status and primary behavior front-loaded, with the redirect to alternatives second. No filler, though the 'Legacy:' label plus 'deprecated' is slightly redundant.

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 legacy delete with no output schema, the agent knows which API it targets and where to go for modern media deletion. Only the destructive/irreversible nature and confirmation behavior are 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?

Only one parameter ('screenshotId') with 100% schema coverage, so the schema already documents everything. The description adds no format, source, or ID-acquisition guidance beyond the deprecated-context framing.

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 ('delete a screenshot') and immediately scopes it to the deprecated screenshot-set API, which distinguishes it from the Asset Library siblings it names.

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

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

Explicitly frames the tool as legacy and routes the agent to apple_delete_placement and apple_delete_asset for Asset Library media. The condition that selects the alternative is spelled out, not inferred.

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

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

With no annotations provided, the brief description carries the full burden of behavioral disclosure. It indicates destruction (delete) but omits critical details such as permanence, cascading effects on associated data, or whether the operation is reversible.

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 extremely concise at only 4 words, but it sacrifices necessary detail for brevity. It is not fluff-free, it is underspecified.

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 has one parameter and no output schema or annotations, the description should provide more context about the operation's effects, success indicators, or error conditions. It lacks completeness.

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

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

The input schema has 100% coverage for its sole parameter, already describing 'groupId' as 'Subscription Group ID'. The description adds no additional meaning beyond the schema.

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

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

The description clearly states the action ('Delete') and the resource ('subscription group'), making the primary purpose unambiguous. However, it does not differentiate from sibling delete tools beyond the resource 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 no guidance on when to use this tool versus alternatives, nor does it mention prerequisites or conditions (e.g., ensuring no active subscriptions before deletion).

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

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

No annotations are provided, so the description carries the full behavioral burden and does not meet it. 'Remove' implies a destructive mutation, but nothing states whether the deletion is permanent, whether it requires the treatment to be in an editable state, or what happens to the treatment if its last locale is deleted.

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 efficient phrase with zero filler and the action front-loaded. The terseness is under-specification rather than verbosity, so it is not penalized heavily here.

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?

A destructive, non-annotated tool with an undocumented required parameter and no output schema needs more than five words. Nothing tells the agent how to obtain a valid localizationId (presumably via apple_list_treatment_localizations) or what the call returns.

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 single parameter is undocumented, but the description does establish that the parameter selects the locale to remove. It leaves the key ambiguity unresolved: whether localizationId is the locale code (e.g. 'en-US') or the opaque ID of an existing localization resource.

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 ('Remove') and resource ('a locale from a treatment'), which is enough to separate it from apple_delete_experiment_treatment and apple_delete_custom_product_page_localization. It stops short of naming those siblings or stating the parent treatment relationship, so a 4 rather than 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?

No guidance on when to use this versus apple_update_treatment_localization or the experiment-treatment deletion tool, no prerequisites (e.g., experiment must be in a draft state), and no mention of what happens when the last localization is removed.

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

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

No annotations are provided, and the description does not disclose any behavioral traits beyond the action itself. No mention of side effects, required permissions, or irreversibility.

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

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

The description is a single sentence and very concise, but it is extremely short and could include more context without becoming verbose.

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

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

Given the tool's simplicity and lack of annotations/output schema, the description is minimal and does not fully inform an agent about the tool's behavior or constraints.

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

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

Schema coverage is 100% with a clear description for the single parameter. The tool description does not add additional meaning beyond what the schema provides.

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 'Disable a capability on a bundle ID' clearly states the action (disable) and the resource (capability on a bundle ID). It directly differentiates from the sibling tool 'apple_enable_capability'.

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 guidance on when to use this tool versus alternatives. No mention of prerequisites or context, such as needing to know the capability ID or that the bundle ID must exist.

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

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

With no annotations, the description carries the full burden. It discloses the segment download + decompress + merge behavior, which is useful, but never states that the tool WRITES A FILE to disk, what happens on overwrite refusal, whether downloading is long-running or rate-limited, or what it returns. The file-writing side effect is only visible in 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?

A single tight sentence with the core action front-loaded and zero filler. It is efficient, though it stops short of including the file-output detail that would make it self-sufficient.

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 4-parameter tool with no annotations and no output schema, the schema covers two of the parameters reasonably well. What is missing is the prerequisite state of the report instance and the on-disk side effect / error behavior when overwrite is false, which an agent needs before calling it.

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

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

Schema coverage is 75%, with maxRows and outputPath (and their interplay, full report to file vs. rows in response) documented in the schema, so baseline 3 applies. The description adds nothing about parameters, and instanceId is undocumented in both the schema and the description.

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

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

The description uses a specific verb ('Download') with a clear resource ('every segment of an analytics report instance') and adds what it does with them ('decompress and merge them into rows'). It implicitly distinguishes itself from the sibling listing tools (apple_list_analytics_report_segments, apple_list_analytics_report_instances) that only enumerate, but it never names a sibling or explicitly contrasts with apple_get_sales_report / apple_get_finance_report.

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 when-to-use guidance, no stated prerequisites (e.g. the report instance must be completed/ready before downloading), and no mention of alternatives. The agent must infer that this follows the list-analytics-report-instances flow.

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

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

With no annotations, the description must disclose behavioral traits. It only says 'Enable' without specifying side effects, whether the operation is reversible, or what permissions are required. Insufficient for a mutating tool.

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

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

The description is a single concise sentence, which is efficient for a straightforward tool. However, it could be slightly more informative without losing conciseness.

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

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

Given no output schema and 3 parameters, the description is too brief. It doesn't explain what the response is, or confirm success. Sibling tools like apple_disable_capability might provide contrast but the description alone is 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 descriptions cover 100% of parameters, and the description does not add meaningful information beyond the schema. The baseline of 3 applies as the schema itself is adequate.

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 (Enable) and the resource (capability on a bundle ID). It distinguishes from the sibling tool apple_disable_capability. However, it does not elaborate on what a capability is in Apple context.

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 guidance on when to use this tool vs alternatives like apple_disable_capability or any prerequisites (e.g., bundle ID must exist). The description does not help the agent decide when to invoke this 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?

No annotations are provided, and the description lacks behavioral details such as authentication requirements, error handling for invalid appInfoId, or any resource limits. For a read tool, basic safety is implied but not disclosed.

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

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

The description is a single concise sentence, front-loading the key purpose. However, it could include more context without harming brevity (e.g., what the declaration contains).

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 lacks an output schema, and the description does not explain what the returned age rating declaration includes. Given the tool is a getter, more detail on the return value is needed for complete understanding.

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

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

The schema already describes the single parameter appInfoId as 'AppInfo ID', which is clear. The description adds no additional meaning beyond what the schema provides, so the baseline of 3 is appropriate.

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

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

The description clearly states the tool retrieves an age rating declaration for an app info. It uses a specific verb (Get) and resource (age rating declaration), and is distinct from sibling tool apple_update_age_rating.

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 guidance on when to use this tool versus alternatives. It does not indicate prerequisites such as needing a valid appInfoId, or note that it's a read-only operation that does not modify data.

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

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

No annotations exist. The description implies a read operation but fails to mention any behavioral traits such as rate limits, authentication needs, or data freshness. The agent gains little insight beyond the obvious.

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

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

Single sentence, no wasted words. Perfectly concise and front-loaded with key action.

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 1-param getter with no output schema, the description covers the essential purpose. However, it could hint at return fields beyond 'latest version state' for full completeness.

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

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

Schema coverage is 100% and the description adds no additional meaning beyond the schema's 'App ID'. Baseline 3 is appropriate as the schema already suffices.

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

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

The description clearly states the tool retrieves detailed app info with latest version state. It distinguishes from siblings like apple_list_apps (list) and apple_get_app_info (possibly a different detail level), though not explicit.

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 guidance provided on when to use this tool over alternatives like apple_get_app_info. No when-not or context clues.

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

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

No annotations provided; description does not disclose any behavioral traits (e.g., read-only nature, authentication needs, rate limits, or side effects). The description only states purpose without any behavioral context.

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

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

Single sentence, efficient but lacks depth. Under-specification prevents higher score for conciseness.

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 one parameter, no output schema, and no annotations, description severely lacks context. Does not specify return format, constraints, or prerequisite information for using the 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?

Only parameter 'appId' has basic description 'App ID' in schema; schema coverage is 100%. Description adds no additional meaning beyond the schema. Baseline score of 3 applies.

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

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

Clear verb 'Get' and resource 'app info' with examples (categories, age rating). However, sibling tool 'apple_get_app' exists with similar purpose, and description does not differentiate between 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?

No guidance on when to use this tool vs alternatives like 'apple_get_app' or other info tools. No context about prerequisites or typical use cases.

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

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

With no annotations, the description carries the full burden. It does disclose one useful behavioral trait — that presigned upload URLs are deliberately not returned — and that processing state and delivery errors are surfaced. However, it says nothing about auth/permission needs, whether 'processing' implies polling, or how failures are signaled, which is a notable gap for an unannotated tool.

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

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

A single front-loaded sentence with no filler; the verb and the returned data lead immediately. It is dense but readable and every clause maps to real behavior.

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 usefully enumerates what is returned (processing state, specId, errors) and what is not (presigned URLs), which partially substitutes for a schema. But with zero annotation and zero param coverage, the guidance on inputs and failure/retry semantics is thin for an agent to call it reliably.

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% across two required params, so the description must compensate and largely does not: assetId is never explained, and mediaType is only obliquely implied by 'image or video'. The mention of 'matched specId' is a concept but not a parameter, adding little parameter-level meaning.

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

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

States a specific verb ('Read') plus a precisely scoped resource: an image or video asset's processing state, matched specId, and delivery errors. This clearly separates it from write-path siblings like apple_upload_asset or apple_delete_asset, though it never names those siblings 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?

There is no explicit when-to-use or when-not-to-use guidance. It's implied you call this to inspect an asset's state, but the description doesn't mention alternatives such as apple_wait_for_asset (for polling) or apple_list_assets (for enumeration), leaving the agent to infer routing.

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

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

No annotations are provided, so the description carries the full burden. It does not state that this is a read-only operation, does not describe the returned structure, does not mention required permissions or rate limits, and does not say what the 'library' contains.

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 wasted clauses. It is appropriately sized for a simple one-parameter getter, though 'reusable' is somewhat vague and the trailing list of asset types adds little precision.

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 tool with no output schema and no annotations, the description should at minimum explain the identifier convention and what the returned library represents. Neither is covered, leaving the agent to guess key details before 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 0% and the single parameter appId has no format guidance. The description says 'for an app', which loosely ties appId to an app identifier, but it does not say whether this is a numeric App Store Connect ID, a bundle ID, or another identifier — a meaningful ambiguity for Apple tooling.

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 ('Get') and resource ('reusable App Asset Library for an app') and scopes it to the appId. The mention of screenshots, previews, and creative assets ties it to asset upload workflows, though it does not explicitly distinguish itself from the many sibling asset tools (apple_list_assets, apple_get_asset, apple_upload_asset).

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 'before uploading screenshots, previews, or creative assets' implies a when-to-use context, but there is no explicit guidance on when not to use it or which sibling tool to choose instead (e.g., apple_list_assets vs apple_get_asset_library).

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

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

No annotations are provided, so the description carries the full burden. It discloses the categories of data returned and the key behavioral rule (prefer returned IDs over hard-coded sizes), which is valuable. It says nothing about auth needs, caching/freshness of 'current' specs, or whether the four inputs act as optional filters that narrow the result set.

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 that leads with the verb and resource, then appends the usage note after a semicolon. No filler, though the semicolon-joined clause packs two distinct ideas (what it returns, how to use it) into one dense statement.

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 reference-data tool with four optional filters and no output schema, the description conveys the general shape of the return (specs, placement types, device groups, limits) but not how the inputs narrow results or what a result entry looks like. Adequate to attempt a call, insufficient to call it precisely.

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, and it only partially does: 'placement types' and 'device groups' loosely hint at placementType and placementGroup. The params specId and feature get no explanation at all, and nothing states that all four are optional filters rather than required selectors.

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?

A specific verb ('Read') plus a precisely enumerated set of resources (asset specifications, placement types, device groups, limits). It is distinguishable from siblings like apple_get_asset or apple_list_asset_placements because it returns reference/spec data rather than concrete assets. It doesn't explicitly name a sibling to contrast with, keeping it just below 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?

The clause 'use the returned IDs instead of hard-coded device sizes' implies the intended workflow (fetch specs first, then pass IDs downstream), which is useful implied guidance. However, it never states when to call this versus apple_get_asset_library or apple_list_asset_placements, and gives no prerequisites or exclusions.

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

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

No annotations are provided, so the description carries the full burden; 'Get' implies a read-only lookup and 'including the imported build when available' usefully flags that the build field is conditional. It does not disclose state values, error behaviour for unknown/expired upload IDs, or any rate/timeout characteristics expected of a status-polling endpoint.

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 front-loaded sentence with no filler; the key resource and the notable response caveat are both up front.

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 and no annotations, the description should say more about what a 'state' contains and what happens before a build is imported. It partially compensates by mentioning the conditional imported build, but the polling semantics and state vocabulary remain 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?

Single parameter with 100% schema description coverage ('Build Upload ID'), so the schema already documents it. The description adds nothing about where that ID comes from (e.g. apple_upload_build's response) or its format, which is the only meaningful gap.

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 ('Get') and resource (a Build Uploads API operation) plus what the response contains ('including the imported build when available'). This distinguishes it reasonably well from apple_upload_build, apple_delete_build_upload and apple_wait_for_build_upload, though it never names the closest 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?

The phrase 'current state' implies a single non-blocking status check, which implicitly contrasts with apple_wait_for_build_upload, but the description never states that contrast or tells the agent when to poll versus wait. Usage is inferable rather than 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?

No annotations are provided, so the description carries the full burden, yet it discloses almost no behavioral traits: no indication of whether versions are returned in full or as references, no behavior when pageId is invalid or the page is unpublished, no auth or permission notes, no pagination hints.

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 short sentence, front-loaded with the verb and resource, with no filler. It is efficiently written but so terse that the brevity reflects under-specification as much as conciseness.

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 annotations, no output schema, and an undocumented required parameter, the description leaves key questions unanswered: what fields the page and its versions contain, whether a missing id errors or returns empty, and how this differs from the version-listing tool.

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

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

Schema description coverage is 0% and the single parameter pageId has no description in the schema or in the tool description. The only clue is the parameter name itself, so the description adds essentially nothing to the parameter's meaning or expected format.

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