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 does not mention that this tool makes an HTTP request and returns a raw response, nor does it warn that POST/PATCH/DELETE methods will mutate data. The only behavioral trait disclosed is the path prefix constraint. This is a significant gap for a tool that can perform destructive operations.

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

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

The description is two sentences, front-loaded with the purpose and usage condition, followed by the path constraint and reference link. There is no wasted text, and every sentence serves a purpose. It is concise and well structured.

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 raw API request tool with no output schema, the description does not explain what the agent should expect as a return value (e.g., raw JSON response). It also does not mention error handling, authentication, or rate limits. The link to documentation helps but is not a substitute for a brief note on the response format or side effects. Given the tool's power and lack of annotations, this 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 coverage is 75%, so the baseline is 3. The description adds valuable constraint on the 'path' parameter (must start with '/v1/' or '/v2/'), which is not in the schema. It also links to the full API reference, which helps the agent understand valid paths and query parameters. This goes beyond the schema and justifies a 4.

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 this is an escape hatch for any App Store Connect API endpoint not covered by a dedicated tool. It distinguishes itself from the sibling tools by explicitly positioning itself as the fallback, and gives a concrete constraint (path must start with '/v1/' or '/v2/'). The purpose is unambiguous and well differentiated.

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 explicitly says to use this tool when an endpoint is not covered by a dedicated tool, which is a clear usage condition. It also provides a path requirement and a link to the full resource reference, giving the agent both the 'when' and the 'where to look' for proper usage. This is strong guidance.

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

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

No annotations are provided, so the description carries the full burden. It discloses the side effect of creating an initial version and the return of the version ID, which is a key behavioral detail. However, it does not mention potential side effects like overcounting points or any rate limits, but for a creation tool, the description covers the essential behavior.

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

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

The description is a single, concise sentence that front-loads the primary action and then provides a crucial secondary detail about the returned version ID. No wasted words; every clause adds value.

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

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

For a creation tool with 6 fully documented parameters, no output schema, and a clear sibling workflow, the description is complete. It explains the return value (version ID) and how to use it, satisfying the agent's need to call the tool correctly and follow up.

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

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

Schema description coverage is 100%, so the schema already documents each parameter. The description adds no parameter-level detail beyond what's in the schema, but it does mention the workflow context (version ID for localization) that is not in the schema. This is enough to meet the baseline of 3.

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

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

The description clearly states the tool creates a new Game Center achievement and additionally the initial version, returning its ID. It uses a specific verb ('Create') and resource ('Game Center achievement'), and it distinguishes itself from the sibling 'create_game_center_achievement_localization' by noting it returns the version ID for subsequent localization creation.

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

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

The description implies the intended workflow: after creating the achievement, the returned version ID is used to add localizations with the sibling tool. It does not explicitly state when not to use this tool or list preconditions, but the context of sibling tools and the schema (e.g., gameCenterDetailId from get_game_center_detail) provides clear usage context.

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

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

Annotations are absent, so the description carries the full burden of behavioral disclosure. It only says 'Add,' which implies a mutation, but it does not disclose whether duplicate locales are rejected, whether existing localizations are overwritten, what permissions are required, or what the API returns. This is a meaningful gap for a create/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?

The description is a single, front-loaded sentence with no wasted words. It immediately identifies the action, target, and scope. It earns its place and does not repeat the title verbatim.

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 simple creation tool with five fully documented parameters in the schema, so the description plus schema gives an agent enough to make a correct call. The lack of an output schema and minor behavioral gaps are noticeable but not crippling given the tool's simplicity and the high schema coverage.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no extra meaning beyond what the schema already provides for name, locale, versionId, and the two description fields. It maps generally to 'localized name/description' but does not clarify formats or constraints 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 a specific action ('Add') on a specific resource ('localized name/description for an achievement version') and scopes it to 'one locale.' This distinguishes it from sibling tools like create_game_center_achievement or create_game_center_leaderboard_localization without requiring the agent to open 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?

The description provides clear context: this tool is for adding a localization to an existing achievement version, for a single locale. It does not explicitly name alternatives or state when not to use it, but the target entity and scope make the intended use reasonably apparent. It lacks explicit exclusions or 'use X instead' guidance.

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

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

With no annotations provided, the description carries the full transparency burden. It usefully discloses a nontrivial side effect: the call also creates the initial leaderboard version required by the API and returns that version's ID. It does not mention authorization or reversibility, but the most surprising behavioral trait is clearly surfaced.

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

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

Two sentences with no filler. The primary action is front-loaded, and the second sentence adds the essential return-value detail and workflow direction without redundancy.

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

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

Given that there is no output schema, the description's explicit mention of the returned version ID is valuable for an agent chaining into create_game_center_leaderboard_localization. It covers the key side effect and follow-up step. It stops short of describing error conditions or permission requirements, but it gives enough to invoke the tool correctly in the intended workflow.

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 89%, which exceeds the high-coverage baseline, so the schema already explains the parameters, enums, and required fields. The description adds no parameter-level detail, which is acceptable because there is little left to clarify 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 states a specific verb and resource: 'Create a new Game Center leaderboard.' It also differentiates this from the sibling localization tool by mentioning that it creates the initial leaderboard version and returns its ID, so the agent can distinguish where one workflow ends and the next begins.

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 context is implied rather than explicit: the description says the returned version ID lets you immediately add localizations with create_game_center_leaderboard_localization, which suggests a follow-up workflow. However, it does not explicitly state when to use this tool versus alternatives, nor does it state exclusions or prerequisites beyond what the schema already captures.

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 says 'Add', which is necessary but not sufficient: it does not disclose uniqueness constraints, what happens if the locale already exists, whether a leaderboard version must exist, or any other side effects. This leaves important behavioral risk unaddressed for a mutating 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, front-loaded sentence with no filler. Every word contributes to purpose and scope, and it avoids restating parameter names or schema details.

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 operation with 7 parameterschery and no output schema, this description is too thin. It omits expected preconditions, uniqueness behavior, format-enum semantics, and guidance on optional fields. An agent would likely need to inspect the schema and sibling tools closely to invoke it correctly.

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

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

Schema description coverage is only 57%, so the description needs to compensate for undocumented parameters like description, formatterOverride, and formatterSuffixSingular. The phrase 'name/format' gestures at those parameters but does not explain their role, meaning, or required combinations, so it adds little 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 states a specific verb ('Add'), a concrete resource ('a localized name/format for a leaderboard version'), and a scope ('for one locale'). This clearly distinguishes it from sibling tools like create_game_center_leaderboard, which creates a leaderboard itself rather than a localization.

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

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

The description implies when to use the tool: when a localization needs to be added to a leaderboard version. However, it does not explicitly mention alternatives, prerequisites, or when not to use it, so an agent has to infer the intended context from the tool name and sibling list.

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 convey behavioral traits. It states the operation is 'permanently delete,' indicating irreversibility, which is valuable. However, it omits other potential behaviors such as side effects on associated localizations or versions, 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 a single, clear sentence with no unnecessary words. It is appropriately concise for a simple delete operation, though it borders on under-specification rather than efficient 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?

For a destructive operation with no annotations and no output schema, the description is too sparse. It does not clarify what happens on success (e.g., returns nothing), any constraints (e.g., cannot delete if in use), or error conditions. The core action is stated, but an agent would lack context for safe invocation.

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

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

Schema coverage is 0%, so the description should explain the single parameter 'achievementId.' It does not mention it at all. While the parameter name is self-explanatory, the description adds no semantic value beyond the schema's type and required flag.

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 ('Game Center achievement'), clearly distinguishing it from sibling tools like create_game_center_achievement or delete_game_center_leaderboard. The intent 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?

No guidance is provided on when to use this tool versus alternatives. It does not mention prerequisites (e.g., the achievement must exist) or contrast with related operations like listing or creating achievements.

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 burden of behavioral disclosure. It does disclose the irreversible nature of the operation ('permanently delete'), which is a critical trait. However, it omits other behavioral aspects such as permission requirements, potential cascading effects, or behavior on invalid IDs, so coverage is minimal.

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 with no unnecessary words. It is appropriately sized for a simple operation, though it omits important details. It is well-structured and front-loaded with the core action, making it easy to parse quickly.

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 delete tool with one required parameter and no output schema, the description should at least explain what leaderboardId is and what happens after deletion. It only states the action and permanence, leaving the agent without guidance on required inputs or expected outcomes. The definition is incomplete for an agent to call correctly.

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

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

Schema description coverage is 0%, and the tool description does not mention the leaderboardId parameter at all. The agent must infer its meaning from the parameter name, which is somewhat self-explanatory but not documented. The description fails to compensate for the missing schema description, leaving a semantic 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?

The description clearly states the action (permanently delete) and the resource (Game Center leaderboard), which is specific and distinct from sibling tools like create_game_center_leaderboard or list_game_center_leaderboards. An agent can immediately understand the tool's purpose without ambiguity.

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 use this tool versus alternatives, no prerequisites, and no mention of conditions like leaderboard existence or ownership. The description provides no context for decision-making, leaving the agent to infer appropriate usage from the name 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?

No annotations are provided, so the description carries the full burden. It discloses that the tool decodes the report and returns parsed rows, including the truncation to 500 rows. However, it does not mention authentication requirements, error conditions, or whether the operation is read-only. This is adequate but not comprehensive.

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

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

The description is two sentences with no wasted words. It front-loads the core action and return behavior, and is well-structured for quick parsing.

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, the description explains the return value as parsed rows and notes truncation. It covers the main behavior and source. It lacks explicit mention of prerequisites or error handling, but for a download tool this is fairly complete. Slight deduction for not specifying authentication or failure cases.

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

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

Schema description coverage is 100%, so all parameters are already documented in the schema. The description adds little beyond mentioning that the report is TSV and that output is truncated, which does not clarify parameter semantics. The baseline of 3 applies since the schema fully handles parameter documentation.

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

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

The description clearly states the action (Download and decode), the specific resource (sales or subscription report from App Store Connect), and the return format (parsed rows truncated to 500). This distinguishes it from sibling tools that focus on apps, builds, or Game Center features.

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

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

The description implies usage for downloading sales or subscription reports, but does not explicitly state when to use this tool versus alternatives. It provides no exclusions or alternative tool names. The intended use is implied by the tool's purpose, but no direct guidance is given.

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 present, so the description must carry the disclosure burden. It adds a meaningful behavioral consequence ('can no longer be installed by testers') beyond the title, but it omits side effects such as irreversibility, permission requirements, and impact on testers who already installed the build.

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 that front-loads the action and outcome with no filler and no repetition of schema information. Every word earns its place.

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

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

For a one-parameter mutation without an output schema, the description covers the essential operation and its intended effect. It is slightly incomplete on behavioral caveats such as reversibility and permissions, but those are secondary to actually invoking 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?

The sole parameter buildId is already fully documented in the schema as 'The build resource ID' (100% coverage). The description adds no additional parameter-level meaning, so baseline 3 is appropriate.

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

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

The description uses a specific action, 'Mark', names the resource ('a TestFlight build'), and states the goal ('can no longer be installed by testers'). This clearly distinguishes it from read-oriented siblings like list_builds and get_build, as well as from review-submission tools.

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

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

The description implies the trigger for use—when a build should stop being installable—but it does not state prerequisites, cautions, or cases where expiration should not be used. No sibling tool covers expiration, so the usage context is self-evident but not made explicit.

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

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

No annotations are provided, so the description must disclose behavior. It only says 'Get details' without specifying what fields are returned, whether it's a read-only operation, or if there are any side effects. For a retrieval tool, this is a minimal safety profile.

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, clear sentence that is concise and to the point. It front-loads the action and resource, with no filler.

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

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

Given that there is no output schema and parameter coverage is high, the description could be more complete by specifying what 'details' includes (e.g., app metadata, version info). However, the context is a simple single-resource retrieval, so it's 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 only parameter (appId) has a description that clarifies it comes from list_apps. The description adds no additional meaning beyond the schema, which 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 it retrieves details for a single app using its App Store Connect app ID. It distinguishes from list_apps (which lists apps) but doesn't explicitly differentiate from other get_* tools like get_app_store_version or get_build.

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 like get_app_store_version or get_build. It doesn't mention prerequisites (e.g., app must exist) or when to prefer it over list_apps.

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

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

No annotations are provided, so the description carries the disclosure burden. 'Get details' transparently signals a read-only retrieval with no obvious side effects. However, it does not mention response contents, error behavior, or any operational constraints, which would add behavioral clarity beyond the tool name.

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 action and resource, with zero filler. Every word contributes to understanding the tool's purpose.

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 single-parameter get-by-ID tool, the description is largely complete. It states the operation, the resource, and how the record is identified. It could be slightly stronger by naming the relevant list alternative or hinting at what 'details' include, but the low complexity keeps the gap minor.

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 versionId parameter already has a clear description ('The appStoreVersions resource ID'). The description's 'by its ID' reinforces the parameter meaning but adds no new semantic detail beyond the schema.

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

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

The description uses a specific verb ('Get details') and resource ('single App Store version record') and adds the scoping qualifier 'by its ID'. This clearly separates it from list-style siblings like list_app_store_versions and other getters like get_app.

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

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

The description clearly implies the tool is for fetching one specific version record when the versionId is already known. It does not explicitly name alternatives or exclusions, but the 'single ... by its ID' phrasing provides enough context to avoid confusion with list operations.

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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It indicates a read operation but does not mention return content, error behavior, authentication needs, or side-effect safety beyond the verb 'Get'.

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 operation and the required input with zero filler or redundancy. It is appropriately sized for a tool this simple.

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 operation with no output schema, the description is largely sufficient to invoke the tool correctly. It does not document the response fields, which is a minor gap, but the low complexity and clear ID requirement make it nearly 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 coverage is 100% and the buildId parameter is already described as 'The build resource ID'. The description's 'by its ID' adds no new semantics beyond what the schema provides, so the baseline score 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 uses a specific verb ('Get') and resource ('details for a single build') and scopes it by 'its ID'. This clearly distinguishes it from list_builds and other sibling operations that operate on different resources or actions.

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 'by its ID' phrasing implies the tool is for retrieving one known build, contrasting with listing builds. However, it does not explicitly state when to use this over list_builds or mention alternatives such as expire_build, leaving the selection logic to the agent's inference.

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

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

With no annotations, the description carries the full behavioral disclosure burden. It discloses the essential behavior: the tool returns a resource ID that other tools need. However, it does not mention response shape, error cases, authorization, or whether this is strictly read-only, so some operational context is missing.

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

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

Two sentences with no filler. The core purpose is front-loaded, and the second sentence adds essential workflow context about why this ID matters. Every word earns its place.

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

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

For a simple one-parameter lookup, the description is mostly complete: it identifies the required parameter, the return value (resource ID), and the practical purpose (required by other Game Center tools). It could be more complete by noting the response format or potential absence of a Game Center detail, but these are minor for this simple 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 coverage is 100% and the single parameter, appId, is already described as 'The App Store Connect app ID.' The description only says 'for an app,' which aligns with the schema but adds little beyond it. The baseline of 3 is appropriate because the schema does the work.

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

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

The description uses a specific verb ('Get') and resource ('gameCenterDetail resource ID'), and states it is for an app. It also explicitly distinguishes the tool from siblings by explaining that this ID is required by every other Game Center tool, so there is no ambiguity about what it does or its role in the workflow.

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

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

The description clearly implies when to use this tool: before any other Game Center tool, since the returned ID is a prerequisite. It does not explicitly name alternatives or state when not to use it, but the context is strong enough for an agent to select it correctly.

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 disclosing behavior. It states the action and filters but does not mention that the default limit is 50, that 'all apps' is subject to the limit parameter, or describe pagination or the response shape. The phrase 'List all apps' could be misleading given the default limit.

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 the action front-loaded and filters appended. No filler or repetition; every word earns its place.

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

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

For a simple read-only list tool with fully documented parameters, the description is mostly adequate, but it omits the response format and does not clarify the relationship between 'all apps' and the limit parameter. With no output schema or annotations, the agent must infer return shape and default 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 fully describes all three parameters (contains match for name, exact match for bundleId, and default/max for limit), so the description adds no extra meaning beyond naming name and bundleId filtering. With 100% schema description coverage, baseline 3 is appropriate.

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

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

The description uses a specific verb ('List'), a precise resource ('apps in the App Store Connect account'), and notes optional filtering, making the core function immediately understandable. It does not explicitly differentiate from sibling tools like get_app or list_app_store_versions, so it misses the higher bar of naming 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 description implies the tool is used when you need the set of apps in the account and mentions optional name/bundleId filters. However, it provides no explicit guidance on when to choose this over sibling tools such as get_app (single app) or list_app_store_versions (versions), and no when-not-to-use conditions.

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

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

With no annotations provided, the description must disclose behavioral traits, but it only says 'list records' without mentioning pagination, ordering, response shape, or read-only nature. It does not even explicitly state that it returns multiple items or if there are any limits beyond the schema's 'limit' parameter.

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

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

The description is a single, concise sentence that front-loads the core action and resource. There is zero wasted wording and it is immediately scannable.

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

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

For a tool with 2 parameters, no output schema, and no annotations, the description should provide more context about what the response looks like, how many versions are returned, and whether there is any ordering or filtering. It lacks these details, leaving an agent uncertain about the tool's behavior beyond the basic action.

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% (appId is described, limit is not). The description does not add any explanation for the limit parameter or clarify how appId is used beyond the schema. It does not compensate for the missing parameter documentation.

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

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

The description clearly states the verb 'List' and the resource 'App Store version records (releases)' for an app. It distinguishes from siblings like get_app_store_version (singular) and list_game_center_leaderboard_versions (different resource), so an agent can easily identify 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?

No guidance on when to use this tool versus alternatives such as get_app_store_version or list_builds. There is no mention of exclusions or conditions that would lead an agent to choose a different tool, leaving the usage context entirely 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 provided, the description carries the full burden. The verb 'List' makes the read-only nature reasonably clear, and the optional filters are stated. However, it does not disclose pagination, result ordering, default limit behavior, or expected response shape.

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

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

A single sentence with no filler; the core action and optional filters are front-loaded. Every word earns its place.

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

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

The description is adequate for invoking the tool with the required appId and optional filters. But with no output schema and no annotations, the lack of return-format, pagination, or default-limit context leaves meaningful gaps for an agent deciding how to use the results.

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 about 75%, with appId, version, and processingState already described in the schema. The description restates the version and processingState filters but adds no new meaning, and the undocumented limit parameter is not clarified 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?

The description states a specific verb ('List'), a clear resource ('builds for an app'), and the optional filtering dimensions (version string, processing state). It is immediately distinguishable from siblings like get_build and expire_build without needing to inspect 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?

The description makes the basic usage explicit: call this when you need to list builds for a given app. However, it does not mention alternatives such as get_build for a single build, nor does it state when not to use this tool, so routing guidance is only 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, so the description carries the full burden. It only says 'List all achievements' and does not disclose pagination behavior, response size limits, authentication needs, or whether localized achievements are included. 'List' implies read-only, but that is implicit rather than explicit.

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 filler. The verb, object, and scope are all front-loaded and immediately actionable.

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

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

For a simple one-parameter read-only list operation, the description is close to sufficient. However, with no annotations and no output schema, the agent lacks guidance on the return shape and possible pagination. The gaps are not severe because the operation is simple and the parameter is well-documented in the schema.

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

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

Schema description coverage is 100% and the single parameter is already documented as 'From get_game_center_detail'. The description adds no additional parameter details, so the 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?

The description uses a specific verb ('List') with a clear resource ('all achievements') and scope ('for a Game Center detail'). It is distinguishable from sibling tools like list_game_center_achievement_versions because it refers to achievements, not versions.

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

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

The description gives no guidance on when to use this tool versus alternatives such as list_game_center_achievement_versions or list_game_center_leaderboards. There are no explicit exclusions or conditions, so the agent must infer routing from sibling names 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?

No annotations are provided, so the description carries the burden of behavioral disclosure. The verb "List" conveys a non-destructive read operation and the parenthetical adds workflow context, but the description does not disclose response characteristics such as whether versions are ordered, paginated, or what fields a version resource contains. The disclosure is adequate but minimal.

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 states the action and the key contextual reason for the call. Every element earns its place and there is no filler.

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

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

For a one-parameter, no-output-schema tool, the description covers the core purpose and why it matters in the localization workflow. But the absence of an output schema and any description of the response places more burden on the text to set expectations about what "version resources" are, which is not addressed. Adequate for the low complexity, with a clear gap in response expectations.

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 does not explain achievementId, its format, or where an agent might obtain it. The parameter's meaning is only inferrable from its name and the phrase "for an achievement." With low schema coverage the description should compensate, and it largely 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: "List the version resources for an achievement." It clearly distinguishes from list_game_center_achievements (which lists achievements themselves) and names the achievement as the target resource, differentiating it from the sibling leaderboard-versions tool. It does not explicitly call out the parallel sibling list_game_center_leaderboard_versions, hence 4 rather than 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 parenthetical "(needed to add localizations)" provides a clear workflow context for when this tool is required, which is useful for an agent deciding whether to call it. However, it gives no exclusions, prerequisites, or guidance on when a sibling like list_game_center_leaderboard_versions would be the right choice instead. Usage is implied rather than explicitly scoped.

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?

There are no annotations, so the description alone must disclose behavior. It indicates a read/list operation but gives no details on pagination, ordering, authorization, or whether 'all' leaderboards are returned in a single response. No side effects or result characteristics are described.

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, direct sentence with no filler or redundancy. It is front-loaded and every word contributes to the meaning.

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 list operation, the schema covers the only required input and the description clarifies the scope. However, with no output schema or annotations, the agent is left without information on response shape, pagination, or failures, so completeness is only partial.

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 is fully documented in the schema as coming from get_game_center_detail. The description only says 'for a Game Center detail' and adds no semantic or format detail beyond the schema. Baseline 3 applies due to 100% 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?

States a specific action (list) and resource (leaderboards) scoped to a Game Center detail, making it distinguishable from sibling tools like list_game_center_leaderboard_versions and create/delete leaderboard tools. The wording 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?

No guidance is given about when to prefer this over siblings or when not to use it, such as requesting leaderboard versions or creating leaderboards. The description simply restates the operation without routing the agent to 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?

With no annotations provided, the description carries the full behavioral disclosure burden. It states only that the tool lists resources; it does not mention that the operation is read-only, what the response contains, whether pagination applies, or any prerequisite permissions. The parenthetical explains why the list is needed, not how the tool behaves.

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 that front-loads the main action and adds only the essential purpose. There is no filler, repetition, or unnecessary 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 simple one-parameter list operation, the description conveys the core invocation context. However, with no output schema and no annotations, an agent is left without information about the shape of returned version resources or any read-only/pagination caveats, so it is only minimally complete.

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

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

Schema description coverage is 0% and leaderboardId has no schema-level description. The description only says 'for a leaderboard', which weakly implies that leaderboardId identifies the target leaderboard, but it does not explicitly define the parameter or its format. The description fails to compensate for the missing schema documentation.

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

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

The description states a specific verb and resource: 'List the version resources for a leaderboard'. It clearly identifies what the tool operates on and adds the contextual purpose 'needed to add localizations'. It does not explicitly differentiate from similar siblings like list_game_center_achievement_versions, though the resource name makes the target 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?

The parenthetical '(needed to add localizations)' provides a clear usage context: call this tool before adding localizations. It does not mention alternatives or when not to use it, so it stops short of full guidance.

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

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

With no annotations, the description carries the behavioral disclosure burden. It is candid about the important side effect: the version is moved into Apple's review queue, signaling that this is a consequential external submission, not a local draft. It does not discuss reversibility or state prerequisites, but the core behavior is explicitly 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 sentence with no filler; the action is stated first and the objective outcome is front-loaded. The title and description together provide all necessary information without redundancy.

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

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

For a low-complexity two-parameter tool with no output schema, the description provides the essential intent and outcome. It lacks usage caveats and state prerequisites, but the schema fully documents the required inputs, and the behavior is clear enough for an agent to invoke it correctly in the obvious case.

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 both parameters include clear descriptions ('App Store Connect app ID' and 'appStoreVersions resource ID to submit'). The tool description adds no additional parameter semantics, so the baseline of 3 is appropriate because the schema already carries the load.

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

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

The description uses a specific verb and object ('Create an App Store review submission for an app store version') and clarifies the real-world consequence ('moving it into Apple's review queue'). This clearly identifies the mutation operation and distinguishes it from the sibling read/list tools such as list_app_store_versions and get_app_store_version.

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 states what the tool does but gives no guidance on when to choose it over alternatives, no prerequisites (e.g., the version must be complete or have valid metadata), and no warnings about when not to call it. An agent must infer usage solely from the name and title.

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