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

Annotations only convey readOnly=false, idempotent=false, destructive=true, and openWorld=true. The description adds substantial non-obvious behavioral detail: it applies only the host-authorized subset, the plan is immutable and current-process scoped, write mode is required, submission is rejected, and unknown outcomes are read back but never replayed. No contradiction with the 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?

Four short sentences, each carrying unique operational meaning with no filler. The action and constraints are front-loaded, and every phrase 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 covers safety, scope, and non-obvious constraints well, but there is no output schema and no explanation of what the tool returns or how the agent should monitor outcomes. 'Unknown outcomes are read back, never replayed' hints at behavior but does not fully equip the agent to handle post-apply verification.

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 planId, digest, operationIds, or authorization beyond vague phrases like 'host-authorized subset.' The agent must rely on parameter names and the schema's type/format constraints, which is insufficient for a required-parameter set of four.

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 ('Apply') and a specific resource ('host-authorized subset of an immutable, current-process domain plan'), and adds clear constraints that set it apart from the plan_* siblings: it executes a plan rather than generates one, rejects submission, and never accepts endpoints or plan-file paths.

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 operational guidance: requires write mode, rejects submission, and excludes endpoint/path inputs. However, it never explicitly names sibling tools or states a when-to-use/when-not-to-use rule, so the agent must infer that this tool is meant to be used after one of the plan_* 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?

Given the inert annotations already declare read-only, idempotent, and non-destructive behavior, the description adds valuable limitations: it states what evidence is used ('bounded App Store Connect evidence') and clearly warns that manual obligations remain and that passing does not guarantee review acceptance. This is meaningful behavioral context beyond annotations.

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

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

Two sentences do meaningful work: front-loading the action and scopes, then clarifying the limits of the result. No redundant wording.

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

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

The description conveys the purpose, scope, evidence source, and limitations, but with no output schema and no parameter explanations, an agent still lacks details on what the check outputs and how to set each argument. It is better than many tools, but not entirely complete for a 4-param check.

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

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

Schema description coverage is 0%, so the description must explain the parameters. It only says 'one specific existing build' and 'those', but it does not define root, platform, version, or buildId beyond the schema's field names. The agent cannot infer how to map arguments to correct values.

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 checks an existing build and release, using specific verb 'check' and a concrete resource. It differentiates itself by focus on 'release readiness' with 'bounded App Store Connect evidence', but doesn't explicitly contrast with get_app_store_state or validate_repository 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?

The description implies its position in a workflow (a pre-submission readiness check) through the 'cannot guarantee Apple review acceptance' caveat, but it never explicitly tells the agent when to use this tool over siblings, nor does it mention alternatives or ordering.

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?

It discloses multiple non-obvious behaviors beyond annotations: local file with mode 0600, never overwrites existing paths, and raw contents never appear in the MCP response. These are key operational constraints that annotations do not provide.

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

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

Two sentences, no filler; the core purpose is front-loaded and the essential constraints are appended succinctly.

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 write tool with no output schema, the description should state what the response contains. It only says raw contents do not appear, leaving the success/error output format unclear, and the term 'approved' is ambiguous.

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 schema coverage at 0%, the description compensates by mapping 'certificate or provisioning profile' to family, 'one exact' to id, and 'new approved local file' / 'never overwritten' to destination. However, it does not address validation details or error cases.

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: download one exact certificate or provisioning profile to a local file with mode 0600. This is sufficiently singular and detailed to distinguish it from sibling planning/listing/get tools, even without naming them.

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

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

There is no mention of when to use this tool versus alternatives, nor any scenario or prerequisite. The description only states what it does, not why/when to choose it over 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?

Annotations already indicate readOnlyHint=false, destructiveHint=false, and idempotentHint=false, so the description adds useful behavioral context: it refuses overwrite, does not export review secrets/notes, and clarifies that screenshot inventory is not original image bytes. This goes beyond the annotations and helps an agent understand side effects and limitations.

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 three sentences, each adding distinct information: the core action, the overwrite refusal, and the exclusions/limitations. It is front-loaded with the main purpose and keeps caveats concise. No wasted words, though the third sentence about screenshot inventory could be clearer.

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 and 0% schema description coverage, the description should explain more about what the export produces, how the destination is validated, and what 'approved' means. It covers key exclusions and the overwrite behavior, but an agent may still be uncertain about the output format and the exact meaning of 'fresh approved local directory'.

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 carries the burden for parameter meaning. It mentions 'destination' implicitly as the local directory and 'appStoreId'/'bundleId'/'platform' as identifiers of Apple state, but it does not explain the 'version' parameter or provide format details beyond the schema patterns. The description adds some context but leaves several parameters under-explained.

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

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

The description states a specific verb ('Read' and 'export') and resource ('Apple state'), and distinguishes itself by noting it exports into a 'fresh approved local directory' and refuses overwrite. It is clear enough to differentiate from siblings like get_app_store_state, though it doesn't explicitly name a sibling alternative.

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

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

The description implies usage context: it is for exporting Apple state to a local directory, and it warns about overwrite refusal and exclusions. However, it does not explicitly state when to use this tool versus alternatives like get_app_store_state or prepare_app_record, nor does it mention prerequisites like having an approved directory.

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

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

Annotations already declare the read-only, idempotent, and non-destructive nature, so the description only needs to add extra behavioral context. It usefully discloses that screenshot/review inventory is redacted and that omitting version changes the result from candidates to detailed metadata, which goes beyond structured annotations.

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

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

Two sentences convey the core action, the two call modes, and the redaction detail without any filler. The most important scoping information is front-loaded.

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 covers the two invocation modes and gives a reasonable sense of return contents, but there is no output schema and no explicit mention of return shape, metadata fields, or error behavior. For a read-only tool with strong annotations this is acceptable, yet some operational details remain underspecified.

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 0% schema description coverage, the description carries the burden for parameter meaning. It usefully explains the effect of the optional version parameter, but it does not add semantic explanation for appStoreId, bundleId, or platform beyond what their names, patterns, and enum already imply.

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 ('Read') and names a clear resource ('verified app/bundle identity'), which is far more informative than a mere label. It also distinguishes two behavior modes (candidate inspection vs. exact metadata read), though it does not explicitly contrast itself with sibling tools like get_bundle_id_state.

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 provides clear guidance on how to vary the version parameter: omit it to inspect candidates, or specify platform/version to read full metadata. However, it does not explain when to choose this tool over get_bundle_id_state or other sibling tools, so tool selection remains inferential.

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

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

The annotations already declare readOnly, idempotentH, and no destructive behavior. The description adds meaningful behavioral context beyond those annotations: it explicitly returns 'absent' when the identifier isn't found, and it disclaims side effects. It doesn't go into pagination, auth, or error codes, but it is sufficient for a read-only one-parameter 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 with no filler: the first establishes what is read, the second covers the return and side-effect behavior. The main purpose and the 'before provisioning.json' context are front-loaded.

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 is simple ('1 parameter, no output schema'), and the description states what is read, the result, how absence is represented, and what potential no. It doesn't give an explicit output shape, but for this level of complexity and with annotations already covering side effects, it is complete enough.

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

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

With 0% schema description coverage, the description must carry the parameter's meaning. It mostly does: it identifies 'identifier' as a bundle identifier and emphasizes 'exact', which clarifies matching semantics implied by the regex. It could give an explicit example but for a single parameter this is enough.

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 explicitly says 'Read one exact bundle identifier and its portal platform/capabilities', giving a specific verb and resource. It distinguishes itself from write/registration workflows by ending with 'never registers anything', which contrasts clearly with sibling tools like prepare_app_record or apply_plan.

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

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

It states a clear usage context: use this before authoring provisioning.json, which is specific and actionable. It doesn't list official sibling alternatives or explicitly say when not to use it, but the 'before authoring' phase plus 'never registers anything' gives strong contextual guidance.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds valuable context beyond annotations by guaranteeing no network access and clarifying that it reports configured safety gates, not live system state.

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 well-structured sentence that leads with the action and object, then adds the key operational constraints. Every word earns its place with no redundancy or filler.

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

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

For a zero-parameter, read-only capability reporting tool, the description fully covers what the tool does and its operational boundaries. An agent can invoke it confidently without needing output format details, especially given the rich annotation 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?

There are zero parameters, so the description carries no parameter burden. The schema already covers everything (100% coverage trivially), and the baseline for 0 params is 4; the description appropriately focuses on behavior rather than 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 states a specific verb ('Report') and a clear resource ('implemented features and configured safety gates'). The added constraint 'without credentials or network access' further distinguishes it from potential siblings like validate_repository, making the tool's identity unmistakable.

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 this is a safe, zero-setup introspection call (no credentials/network needed), which gives context for when to use it. However, it does not explicitly name alternatives or state when not to use this tool, despite the sibling validate_repository being present.

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

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

Annotations already declare readOnlyHint and idempotentHint, and the description adds value by explaining that polling never executes writes and that journal files persist after process exit. This goes beyond the structured hints without contradicting them.

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

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

Three sentences with no wasted words, front-loading the primary purpose and then adding important behavioral details. The structure is efficient and logically ordered.

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 covers purpose, polling behavior, and persistence, but lacks explicit parameter explanations and any indication of the output format. Given the simple two-parameter schema and no output schema, it is adequate but has notable 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 0%, so the description must compensate for parameter meaning, but it does not explicitly explain planId or the poll parameter. It only alludes to polling behavior implicitly, leaving parameter semantics largely undefined.

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 inspects a current-process plan journal, with a specific verb and resource. It implies read-only inspection and distinguishes from execution tools by noting it never executes remaining writes, but it does not explicitly name sibling tools.

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

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

The description provides clear context: polling reads back previously approved uncertain operations, and execution requires a fresh plan. It implies when to use this tool (for status inspection) versus alternatives (execution), but does not explicitly reference 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?

The annotations cover read-only and idempotent behavior, but the description adds meaningful extra disclosure: the response excludes artifact contents and transforms serial numbers, UDIDs, and profile UUIDs via fingerprinting. This warns the agent about both privacy handling and the absence of raw artifact data, which is beyond what the annotations provide.

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

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

The description is tightly packed across two sentences: the first gives the primary read semantics and exclusions, the second clarifies identity handling and planning value. There is no fill text or redundant restatement of the tool name or annotations.

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 no output schema, the description does a good job of saying what will and will not be returned: no artifact contents, exact IDs present, and sensitive fields fingerprinted. It still leaves some ambiguity about the overall response shape, counts, or per-family structure, which makes it slightly less complete than it could be.

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 schema description coverage at 0%, the description should compensate for the two parameters, but it largely does not. It indirectly implies resources via 'certificates, devices, profiles' and mentions IDs, but it never explains how the 'ids' array is interpreted or how 'family' controls the result set. The schema's enum and names must do the heavy lifting.

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

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

The description begins with a specific verb and resource: 'Read bounded certificate, device and profile inventory.' It clearly distinguishes itself from artifact-downloading and planning siblings by stating 'without artifact contents' and explaining that IDs are available while serials, UDIDs, and UUIDs are fingerprinted.

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 signals a clear use case: obtaining exact IDs while avoiding artifact contents, likely as a precursor to 'typed planning.' It does not explicitly name sibling alternatives or provide a direct when-to-use / when-not-to-use contrast, but the context is strong enough that an agent can infer the appropriate workflow.

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

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

Annotations already indicate read-only, idempotent, non-destructive behavior, and the description adds meaningful operational context beyond those hints: it uses plutil, performs no xcodebuild or scripts, leaves unresolved settings provisional, and never registers identifiers. This gives an agent an accurate model of side effects and limitations beyond the structured 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?

The description is compact and front-loaded: it states the core operation first, then the exclusions, then the behavioral caveat. Every sentence adds distinct value, with no filler or redundant restatement of 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 six-parameter signature and absence of an output schema, the description is adequate for understanding scope and side effects, but it leaves gaps around parameter relationships (root vs project vs workspace) and what the inspection actually returns. It is minimally viable but not fully complete for an agent invoking the tool without additional schema help.

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 carries the burden of explaining parameters, but it only mentions target, configuration, and platform. It does not clarify the semantics of root, project, or the mutually exclusive/co-occurring workspace parameter, which are necessary to invoke the tool correctly.

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 ('statically inspect') tied to a precise resource (an explicit app/extension target, configuration, and platform) and names its method (Apple plutil). It clearly distinguishes itself from sibling tools by scoping to a single explicit target and explicitly ruling out xcodebuild, scripts, dependency resolution, and project edits.

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

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

The description gives clear context for when this tool is appropriate: static inspection only, with no dynamic build behavior or project mutation. It explicitly states what it will not do, but it does not name specific sibling alternatives or provide an explicit when-to-use/when-not-to-use decision rule.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds a useful behavioral nuance: bundle ID is an exact filter and names are not identity, which helps an agent understand matching semantics. It does not disclose pagination, result ordering, or what happens when no bundleId is provided, but the annotations carry the main safety burden.

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 no filler. The core purpose is front-loaded, and the second sentence adds a high-value filtering caveat. 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 two optional parameters and no output schema, the description is mostly adequate. The main missing piece is the meaning of limit and the result shape, but the annotations cover safety and the description covers the key identity caveat. It is not as complete as it could be, but it is not severely deficient.

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

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

Schema description coverage is 0%, so the description must compensate for the two parameters. It does clarify that bundleId is an exact filter and that names are not identity, which adds meaning beyond the schema's raw string type. However, it does not explain the limit parameter's behavior, default, or interaction with bundleId, leaving a 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 states a clear verb ('Discover') and resource ('apps through public Apple API reads'), and adds a meaningful scoping note that bundle ID is an exact filter while names are not identity. It doesn't explicitly name a sibling alternative, but the phrase 'public Apple API reads' distinguishes it from planning/apply/submission tools in the sibling list.

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

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

The description implies usage context: it is a read-only discovery tool for apps, and the bundle ID note gives a hint about how to filter. However, it does not explicitly state when to use this tool versus alternatives like get_bundle_id_state or get_app_store_state, nor does it mention any exclusions or prerequisites.

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

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

The annotations provide readOnlyHint=false, openWorldHint=true, idempotentHint=false, and destructiveHint=false. The description adds meaningful behavioral context beyond these: it explains that territory availability differences come back as manualActionRequired with blocker statuses and no write operations, and that exact catalog points use decimal strings. This helps the agent anticipate outcome shape even without an output schema.

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

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

Two dense sentences carry the main use case, an important input constraint (decimal strings), and a key behavioral limitation (no write operations for availability). The description is economical and front-loaded, though the placement of the decimal-string rule could be slightly more integrated with the parameter 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 covers the main purpose and an important limitation, including what happens for availability differences. But with no output schema, it does not describe the return shape for pricing plans, nor does it clearly explain how manualActionRequired and blocker statuses are represented. Some operational context is still missing for an agent to confidently invoke 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?

Schema description coverage is 0%, so the description must compensate. It gives some semantic guidance: 'Exact catalog points use decimal strings' clarifies the root parameter's value format, and the domains enum maps naturally to pricing vs availability. However, it does not explicitly describe what root represents or what values are expected for each domain beyond the enum.

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's purpose: planning app-wide base pricing and comparing territory availability. It uses a specific verb and resource and is semantically distinct from sibling planning tools like plan_metadata_changes, but it does not explicitly name or contrast a sibling to sharpen differentiation.

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 this tool is for planning rather than applying changes: it says generic territory mutations are unavailable and that availability differences are returned as manualActionRequired with no write operations. However, it does not explicitly state when to choose this over apply_plan or other plan_* tools, leaving some inference required.

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?

Discloses that secrets remain redacted and that actual writes are deferred to approved apply_plan, behavior not present in annotations. Adds a prerequisite for new versions. No annotation contradiction.

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 purposeful sentences with the core purpose first and caveats after. The releaseType reference is potentially confusing but not 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?

For a six-parameter tool with no output schema and no parameter descriptions, the description omits essential guidance on the root parameter, locale semantics, and how the returned plan is represented. The unresolved releaseType mention adds ambiguity, so an agent cannot reliably construct 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?

With zero schema descriptions, the description explains how domains behave (locale-only appInfo/versionMetadata doesn't cover categories etc.) and that new versions require the version domain. However, it leaves root, locales, platform, and manageCategories undefined and mentions releaseType, which is not present in the schema.

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

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

States it plans selected AppStore locales/domains against an editable app/platform/version. The added caveat about what locale-only appInfo/versionMetadata does not cover helps distinguish from broader planning tools, though no sibling tool is named.

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 routes actual writes to apply_plan, giving a clear alternative for execution. The caveat about categories/copyright/release/review exclusion clarifies what this plan covers, but it does not compare with other plan_* siblings.

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

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

Annotations already signal readOnlyHint=false, idempotentHint=false, destructiveHint=false. The description adds specific behavioral boundaries: 'Preserves omitted capabilities, never deletes signing resources or rewrites projects' and warns that 'Capability changes can invalidate profiles.' This goes beyond the annotations without contradicting them.

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

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

Two dense sentences, with the core purpose front-loaded and caveats packed into the second sentence. Every clause earns its place, and there is no restating of schema or annotation fields.

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, describing the result as an 'immutable approval plan' is helpful but thin. The missing `root` parameter semantics and the lack of explicit tool routing leave some gaps, although the simple two-parameter surface keeps the description workable.

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 partially clarifies `identifiers` as 'exact identifiers explicitly selected from AppStore provisioning.json', but the required `root` parameter is never explained, and the identifier format/meaning is only implied by the schema pattern. This is insufficient for a two-required-parameter tool with no schema descriptions.

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

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

The description names a specific verb and resource: 'Read exact identifiers explicitly selected from AppStore provisioning.json and produce an immutable approval plan.' It distinguishes itself from fellow planning tools by scoping to provisioning identifiers and explicitly excluding signing-resource/project mutation.

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 as a planning step through 'approval plan', and states that 'regeneration and APNs credentials are separate owner tasks.' However, it never names an alternative tool or an explicit 'use when / use instead' condition, leaving routing to inference.

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

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

Annotations already provide readOnlyHint=false, openWorldHint=true, and destructiveHint=false, but the description adds key behavioral nuance: merge does not remove verified images, replace does, pending/unknown bytes block merge, and writes only happen through an approved apply_plan. This is valuable vector beyond the annotation 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?

The description is highly dense and front-loaded, with each sentence compact: purpose, merge/replace behavior, precondition, application workflow. However, the phrasing uses jargon without definition (e.g., 'capacity gap', 'decoded original bytes', 'final states'), which forces the agent to infer too much from too few words, even if each word is intended to earn 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 tool with no output schema and fairly subtle behavior differences, the description leaves gaps: how to handle pending/unknown bytes, what a plan contains, what 'final state' looks like, and how to report or review the plan. The overall purpose is clearer than many tools, but the complexity of the merged/replaced object is substantial enough that the description should provide more 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?

With 0% schema description coverage, the description is expected to explain parameters such as root, locales, version, and platform. The description vaguely suggests 'locales' from the name and 'decoded original bytes' may map to root, but it doesn't clarify what root points to, how version is used, or which locale syntax is expected. This leaves the agent guessing.

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 that the tool 'plans exact macOS locale change sets from decoded original bytes,' giving a specific verb and resource, and the sibling list clearly separates it from provisioning, metadata, commerce, and signing plan tools. It stops short of a fully plain-language statement of what screenshot lucid sets are or why 'decoded bytes' matter.

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 concrete guidance on when to prefer merge (preserves verified unpaid images) versus replace (explicitly shows removals and missing) and sets a precondition (pending bytes require recovery before merge). It doesn't explicitly name an alternative sibling tool, but no other sibling handles screenshot locale plans, so the implicit guidance is sufficient.

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

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

Annotations already declare destructiveHint=true, so the description goes beyond that by adding precise constraints: CSR files must stay under an approved root, private keys are rejected, destructive actions show affected profile counts, and apply requires an exactly matching approved operation. This is genuinely additive behavioral context, and there is no contradiction.

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?

Four sentences, each earning its place: purpose statement, CSR/private-key constraint, destructive behavior note, and the apply contract. The primary purpose is front-loaded, and the text stays tight without unnecessary 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 the tool's complexity (a single `action` property with six oneOf variants) and no output schema, the description covers the non-obvious behavioral facts that an agent cannot derive from the schema: root approval, private-key rejection, one-action-per-plan constraint, destructive-action reporting, and the exact-match contract for apply. Return-value details are not explained, but the absence of an output schema puts the focus on these semantics.

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 0% schema description coverage, the description partially compensates: it explains the intent of `root` (approved root for CSRs, private keys rejected) and `action` (one explicit lifecycle action, destructive variants segregated). It does not enumerate the six discriminated action variants, but those are already fully self-documented through the schema's const/enum structures.

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

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

The description opens with a specific verb and resource: 'Plan one explicit sensitive certificate, device or profile lifecycle action.' It clearly scopes the tool to certificate/device/profile lifecycle work, which distinguishes it from sibling planning tools like plan_provisioning_changes, plan_screenshot_changes, and plan_metadata_changes whose resource domains differ.

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 conveys a two-phase workflow ('Plan one explicit...', 'Apply requires the exact approved operation') so an agent knows it is used to stage changes before apply_plan executes them. It also delineates destructive revocation/deletion as a separate category. It stops short of naming alternative planning tools explicitly, so it earns strong but not top marks.

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 declare readOnly=false and destructiveHint=true, and the description matches that by saying it creates a plan. It additionally covers reuse of compatible drafts, blocking on conflicts, immutable results, required manual confirmations, and automatic-release behavior reporting — all beyond what annotations provide.

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

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

Three dense sentences, each adding useful information with no filler. The primary action is front-loaded, and constraints are laid out clearly without repetition.

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

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

The description states what the tool does and its main constraints, but no output schema exists and the description does not mention return behavior beyond reporting 'automatic-release behavior'. Given the tool’s nested parameter complexity and 0% schema coverage, more context about what a plan contains and how it is later used would make it 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%, so the description should compensate. It only illuminates manualConfirmations ('explicit manual confirmations') and indirectly buildId ('one exact processed build'), leaving root, platform, and version unexplained. For 5 required parameters, this is a 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?

The description states a specific action: creating a fresh, immutable, submission-only plan for one processed build. It distinguishes itself from sibling plan_* tools by limiting scope to submission and by noting that only exact processed builds are eligible.

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 clearly implied for submission planning, and contextual rules are provided: compatible drafts are reused, conflicting submissions block planning. It does not explicitly name alternatives, but the 'submission-only' scope and blocking conditions make the intended context clear.

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

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

Annotations already carry readOnlyHint=true, openWorldHint=true, idempotentHint=true, destructiveHint=false, which cover the safety profile. The description adds useful behavioral context beyond that: the two modes (confirm existing vs. report owner-supplied fields when absent) and the explicit 'Never creates an Apple app record' boundary. No contradiction with annotations.

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

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

Two sentences with zero fluff. The core behavior is front-loaded, and the crucial 'never creates an Apple app record' constraint is immediately present, so the most decision-relevant information is visible before the optional 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?

The tool has six parameters, zero schema field descriptions, no output schema, and a description that never enumerates the manual bootstrap fields nor how the result is returned. The key mutation-safety is covered by annotations, but enough ambiguity remains that an agent cannot confidently construct a correct call without opening additional resources.

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 textual description only vaguely references 'by ID/bundle' and 'manual bootstrap fields.' It does not explain the relationships between bundleId, appStoreId, sku, name, platform, and primaryLocale, nor what 'owner-supplied manual bootstrap fields' means concretely. With six parameters, the description carries too little semantic 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+resource pattern: 'Confirm an existing app by ID/bundle or report owner-supplied manual bootstrap fields when absent.' The explicit negation 'Never creates an Apple app record' clearly distinguishes it from create-style siblings. An agent can reliably tell what this tool is for without opening the schema.

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

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

It implies when to use the tool: when confirming an app exists via bundle ID/appStore ID, or when supplying manual bootstrap fields that are absent. However, it does not explicitly name alternative sibling tools or draw a when-not-to-use boundary beyond creation, so the agent must infer where this fits among the many planning and inspection tools.

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

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

Annotations already signal destructive, non-idempotent, non-read-only behavior; the description adds valuable operational caveats: exact digest, separate submission flag, explicit host confirmation, and read-back of uncertain outcomes without replay. These details go beyond the structured hints and meaningfully reduce risk.

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 dense sentences with no filler. The purpose is front-loaded, and the safety requirements are listed compactly in the second sentence. Every clause contributes useful information.

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

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

For a destructive external submission action with four required parameters and no output schema, the description covers purpose and prerequisites but omits key operational details such as the meaning/source of operationIds, what happens on verification failure, and what the result looks like. It is minimally viable 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 coverage is 0%, and the description only gives partial guidance for a few fields: the digest must be exact and host confirmation must be explicit. It does not explain planId, operationIds, or the authorization object enough, leaving the agent to infer meaning from names alone.

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

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

Description states a specific verb ('Execute'), a specific resource ('submission-only plan'), and constraints ('exact fresh'), clearly separating it from planning siblings like plan_submission and from generic execution like apply_plan. It identifies the tool as an execution/actuation step, not a read-only or planning step.

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 clear contextual prerequisites: only valid when the caller has --allow-writes, the separate --allow-submission flag, the exact digest, and host confirmation. It does not explicitly name alternatives or state when-not-to-use, but the submission-only plan phrase is enough to route an agent toward this tool over planning tools.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, but the description adds meaningful context beyond that: it operates offline, does not execute project tools, requires no Apple credentials, and omitted fields remain unmanaged. This gives the agent important behavioral information that structured annotations alone do not convey.

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 filler. The primary action and scope are front-loaded, followed by compact behavioral constraints. Every sentence earns its place.

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

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

The description is strong on safety and environmental context (offline, non-mutating, no credentials) but weaker on operational completeness. With no output schema and zero schema description coverage, it should also clarify what validation results look like and how the five parameters relate to the validation scope. The missing parameter detail and output expectations keep this from being fully 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%, so the description carries the burden of explaining parameters. It references 'domains/locales' generically but does not explain the required 'root' parameter, nor 'version' or 'platform', and gives no guidance on how omitted fields relate to the schema. The phrase 'Omitted fields remain unmanaged' hints at behavior but does not clarify parameter semantics.

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

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

The description uses a specific verb ('Validate') and identifies the resource scope ('selected AppStore domains/locales') plus the offline nature of the operation. It is clear enough to differentiate from a general validation tool, though it does not fully explain what 'validate' means in terms of checks or output.

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 for when to use this tool: offline validation without Apple credentials, and it explicitly states what the tool does not do (mutate files, execute project tools). It stops short of naming an alternative tool or giving an explicit when-not-to-use statement, so it loses one point.

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