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

No annotations provided, so description must disclose behavioral traits. It mentions removal (destructive) but does not discuss reversibility, permissions, safety, or side effects (e.g., impact on other tools). Lacks transparency expected for a deletion 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?

Single sentence of 18 words, front-loaded with the verb 'Remove'. No extraneous information, highly efficient.

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 tool with 2 optional parameters and no output schema, the description covers the basic purpose and modes. However, it lacks detail on behavior when both parameters are provided, the meaning of 'local', and whether the operation is reversible. Adequate but not fully comprehensive.

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 description must add meaning. It explains that 'buildRunId' identifies a build run and 'maxAgeHours' sets a retention window, and implies an either/or usage. However, it does not clarify edge cases (e.g., both parameters provided) or constraints (e.g., maxAgeHours limits).

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 (remove) and the resource (saved local log directories), and distinguishes two modes of operation (by build run ID or by age). No sibling cleanup tools exist, so differentiation is not needed.

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 two explicit use cases (removing logs for a specific build run or by age), but gives no guidance on when not to use, prerequisites, or alternatives. The mutual exclusivity of parameters is implied but not clarified.

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

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

With no annotations, the description carries the full burden and does well: it discloses the destructive replacement of ALL existing actions and start conditions, notes that enabled state is preserved, and names a required precondition. It doesn't state reversibility, permissions, or response behavior, which keeps it from a 5.

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 with the core action front-loaded and each sentence carrying distinct information (scope, prerequisite, preserved state, exclusion). No filler, though the density makes it read like a checklist.

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

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

For a mutation tool with no annotations, no output schema, and 4 undocumented required parameters, the description covers behavior reasonably but leaves the parameter surface unexplained. An agent knows what the tool does to a workflow but not what to supply for workflowId, scheme, or audience.

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

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

Schema description coverage is 0% across 4 required parameters, so the description must compensate and largely doesn't. 'One exact branch' loosely maps to branch and 'macOS archive' gestures at scheme, but workflowId and buildDistributionAudience (with its INTERNAL_ONLY/APP_STORE_ELIGIBLE enum) are never 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?

States specific verbs and resources: replacing all actions with a macOS archive and all start conditions with manual builds from one exact branch. This is clear and distinguishable from sibling operations update_workflow_actions and update_workflow_start_conditions since it combines both. It does not explicitly name siblings, but the compound scope is unambiguous.

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

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

Gives an explicit prerequisite ('Requires TestFlight Deployment Preparation') and an explicit exclusion with an alternative ('Does not configure tester-group post-actions; use Xcode or App Store Connect for those'). It stops short of stating when to choose this over the granular update_workflow_actions/update_workflow_start_conditions siblings, so it's clear but not fully routing.

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

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

Without annotations, the description carries full burden. It uses 'Resolve' which could imply mutation, but doesn't clarify side effects, permissions, or state changes. No behavioral traits beyond the basic action are 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, which is concise but lacks clarity due to the ambiguous term 'Resolve'. It could be more efficient by directly stating the function.

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 4 parameters, no output schema, and no annotations, the description is severely incomplete. It does not specify required parameters, return format, or usage context, leaving the agent without sufficient information.

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 adds no meaning to the four parameters (buildRunId, workflowId, buildNumber, buildSelector). It does not explain which parameters are needed or how they relate to 'resolve' or 'issue counts'.

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 it resolves a build and returns identity plus issue counts, providing a specific verb and resource. However, it does not differentiate from sibling tools like get_build_logs or get_failed_tests, which also deal with build issues.

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

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

No guidance is provided on when to use this tool versus alternatives. There are no prerequisites, exclusions, or context for usage.

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 key actions: resolve, download, save, return summary. But with no annotations, it misses details on side effects (temp file lifecycle), permissions, or rate limits. The mention of 'temporary local directory' hints at cleanup but is ambiguous.

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

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

Single sentence conveying multiple aspects efficiently. Could be broken into two for clarity, but no redundancy or fluff.

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

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

Despite clear purpose, the description omits parameter semantics and return format details. For a tool with 5 optional parameters and no output schema, it is insufficiently 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?

Parameters (buildRunId, workflowId, buildNumber, buildSelector, maxCharacters) are undocumented in schema and description. The description adds zero information about how to specify the build or limit output, leaving the agent to guess.

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 resolves a build, downloads log artifacts, saves locally, and returns a summary with failures and paths. However, it does not explicitly differentiate from sibling tools like materialize_build_logs or get_failed_tests.

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 explicit guidance on when to use this tool versus alternatives. The description implies usage for local log inspection but lacks prerequisites, when-not-to-use, or comparisons to 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?

The description discloses that it resolves a build and materializes logs locally, which are behavioral traits beyond the read-only implication of the name. However, it is unclear if these are side effects or prerequisites, and without annotations, the transparency is incomplete.

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

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

The description is a single sentence, but it tries to convey multiple actions productively, making it dense and potentially confusing. It could be split into clearer statements.

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 4 parameters, no annotations, no output schema, and related sibling tools, the description is incomplete. It does not explain what the tool returns (beyond 'failed tests'), how to interpret parameters, or how it integrates with other tools for a complete 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?

The input schema has 4 parameters with 0% description coverage, and the description adds no meaning or guidance on how to use them. Parameters like buildRunId, workflowId, buildNumber, buildSelector are not explained in the context of the tool's operation.

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 'Resolve a build, ensure logs are materialized locally, and return only the detected failed tests...' which mixes multiple actions beyond just retrieving failed tests. It is vague about the primary function and does not clearly distinguish from sibling tools like get_build_logs, get_test_results, and materialize_build_logs.

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_test_results or materialize_build_logs. The description does not mention prerequisites or context for usage.

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 indicates a read operation (return metadata and URLs) but does not disclose behavioral traits like authentication requirements, rate limits, error handling (e.g., what if build not found), or whether the operation is destructive. The description only gives high-level purpose without essential behavioral details.

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, 16 words, with no redundancy. It is front-loaded with the verb 'Resolve.' However, given the complexity of 4 parameters and no schema descriptions, the conciseness comes at the expense of completeness. It could be slightly longer to add parameter guidance without being 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?

With 4 parameters, no output schema, no annotations, and 15 sibling tools, the description is insufficient. It does not specify inputs, output format, constraints, or usage context. For a tool that resolves builds and returns artifacts, important details like required parameter combinations, download URL structure, and metadata fields are missing.

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

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

Schema description coverage is 0%, meaning no parameter descriptions in the schema. The tool description does not mention any parameters or explain how they identify the build. It does not clarify the role of buildRunId, workflowId, buildNumber, or buildSelector, nor does it explain the enum values for buildSelector. An agent cannot infer how to construct input.

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 resolves a build and returns metadata and download URLs for UI test artifacts and result bundles. The verb 'resolve' and 'return' combined with the specific resource (UI test artifacts and result bundles) gives a clear purpose. However, it does not differentiate from sibling tools like get_test_results or get_build_logs, which could also return test-related data.

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 when-to-use or when-not-to-use guidance is provided. The description implies usage when needing test artifacts from a build, but there are many sibling tools with overlapping functionality (e.g., get_build_logs, get_test_results) and no alternatives or exclusions are mentioned.

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

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

No annotations exist, so description must cover behavioral traits. It only lists return content without mentioning side effects, authorization, rate limits, or error states. For a build-resolution tool, better transparency is needed.

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

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

Single sentence listing multiple return types is concise but slightly run-on. No structural issues, but could be clearer with bullet points.

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 4 parameters with no descriptions and no output schema, the description fails to provide enough context for correct invocation. Missing parameter guidance and return format details.

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?

0% schema description coverage means schema provides no parameter details. Description does not mention or clarify the meaning of buildRunId, workflowId, buildNumber, or buildSelector, leaving the agent blind on how to specify the build.

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 the tool returns build-level test summary, log paths, failed tests, and bundle metadata. While clear, it does not explicitly differentiate from sibling tools like get_failed_tests or get_build_logs, but the broader scope is implied.

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 like get_failed_tests or get_build_logs. No prerequisites or context provided.

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

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

No annotations provided, so description carries full burden. It discloses that the tool retrieves configuration details (read-only), but does not mention any behavioral traits like required permissions, idempotency, or error conditions. The verb 'Retrieve' implies safety, but not 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?

Single sentence, 15 words, immediately conveys purpose. No redundant or filler 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 simple retrieval tool with one parameter and no output schema, the description adequately lists the included configuration aspects. However, it could mention potential error scenarios or prerequisites (e.g., workflow existence).

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 has one parameter (workflowId) with 0% description coverage. The tool description does not explain the parameter's format, source, or constraints, leaving the agent to infer its meaning from context.

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 clearly states verb 'Retrieve' and resource 'detailed Xcode Cloud workflow configuration', listing specific included fields (environment, start conditions, actions, enabled state). This distinguishes it from sibling tools like list_workflows (listing summaries) and update_* 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?

No explicit guidance on when to use vs alternatives, but the description implies it is for retrieving detailed configuration of a specific workflow, contrasting with listing or update tools. Lacks explicit when-not-to-use 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?

Description reveals automatic pagination and limit control, which are behavioral. However, it omits read-only nature (no annotations) and other traits like ordering, rate limits, or failure modes.

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

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

Two concise sentences front-loaded with purpose and key behaviors. No superfluous words; every sentence 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?

With no output schema and no annotations, the description covers listing, filtering, pagination, and limit. However, it lacks order details, result structure, and prerequisites, so it's not fully complete for a 3-parameter 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?

Description explains the status parameter as filtering by outcome and the limit parameter as capping results, adding meaning beyond the schema (which only documents limit's range/default). This complements the 33% 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?

Description clearly states the tool lists build runs for a workflow, with optional filtering by outcome. The verb 'list' and resource 'build runs' provide clear purpose, distinguishing it from siblings like get_build_issues or get_build_logs.

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 explicit guidance on when to use this tool vs. alternatives. It mentions filtering and pagination but doesn't contrast with sibling tools or specify prerequisites (e.g., workflow exists).

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

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

The description adds the behavioral detail of automatic pagination, which is helpful. However, it does not explicitly state that the operation is read-only or non-destructive, and no annotations are provided to clarify this. For a list operation, this is a minor gap.

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

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

The description is two short sentences with no wasted words. The primary action is front-loaded in the first sentence, and a key behavioral detail follows in the second.

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 tool with no output schema, the description covers the essential purpose and automatic pagination. It does not describe the structure of returned data, but given the tool's simplicity, this is acceptable. It could be improved by explicitly noting it is a read operation.

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

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

With zero parameters, the input schema provides no information. The description compensates by explaining the purpose and pagination behavior, adding meaning beyond the schema. Baseline for no params is 4, and this description meets it.

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

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

The description clearly states the verb 'List' and the resource 'Xcode Cloud products' within the context of the configured App Store Connect account. It naturally distinguishes itself from sibling tools which focus on builds, logs, and workflows.

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 does not provide explicit guidance on when to use this tool versus alternatives, nor does it mention when not to use it. However, given that no sibling tool lists products, the usage context is somewhat 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?

With no annotations, the description carries full burden. It discloses automatic pagination but omits read-only nature, authentication needs, data limits, or error behavior. Acceptable but not thorough.

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

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

Two concise sentences, front-loaded with the core action, then add pagination detail. No fluff or 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 no output schema and 14 siblings, the description provides minimal context beyond the operation. Lacks details on response structure, output fields, or how 'workflows' are represented. Adequate but not complete.

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

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

Schema coverage is 0%, yet the description only implies productId but does not explain its format, how to obtain it, or its role. No compensation for the lack of 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?

Clearly states the verb 'list' and resource 'workflows for a given Xcode Cloud product', with additional detail on automatic pagination. Distinguishes from sibling like get_workflow_details by implying listing all.

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?

Specifies the context ('for a given Xcode Cloud product') but does not mention when to use this tool vs alternatives like get_workflow_details, nor any usage restrictions 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 description outlines the process (resolve, download, extract, return paths) but omits side effects like temporary directory lifecycle and cleanup. With no annotations, the description carries the burden; it is adequate but not thorough.

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 covering the main action. It could be improved by front-loading the purpose and adding parameter hints, but it remains efficient without fluff.

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

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

With 4 parameters, no output schema, and no annotations, the description lacks essential details like parameter purposes, output format, and prerequisites (e.g., build existence). It is insufficient for a tool of this complexity.

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

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

Schema description coverage is 0%, and the description does not explain the parameters (buildRunId, workflowId, buildNumber, buildSelector). It only vaguely mentions 'resolve a build' without clarifying how parameters affect behavior.

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 resolves a build, downloads and extracts text-like log artifacts, and returns file paths for investigation. It uses specific verbs and resources, and distinguishes from siblings like get_build_logs by emphasizing materialization to local files.

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_build_logs or cleanup_saved_logs. It mentions 'for grep or cat based investigation' but lacks explicit when-to-use or when-not-to-use criteria.

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

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

No annotations are provided, so the description carries full burden. It only states the mutation action without disclosing side effects, permissions, or idempotency. Minimal behavioral context given.

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, front-loaded with the action and resource, with no unnecessary words.

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 toggle tool, the description conveys the core action but lacks parameter details and any behavioral caveats. Given no output schema, it is 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 description coverage is 0%, and the description does not explain the parameters at all. It fails to add meaning to workflowId or enabled beyond their names and types.

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 explicitly enables or disables an Xcode Cloud workflow, using a specific verb and resource. It distinguishes from sibling tools that handle other aspects like actions or general settings.

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 but does not provide explicit guidance on when to use this tool versus alternatives like update_workflow_general, nor does it mention when not to use it.

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

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

Annotations already declare readOnly=false, idempotent=false and openWorld=true, so the safety profile is covered. The description goes further by disclosing that repeat invocations create additional build runs and that individual build-run cancellation is not supported by Apple's public API – a real operational consequence the agent cannot infer from structured fields.

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, front-loaded with the core action, each carrying useful information. Mild redundancy between 'creates a new build run' and 'repeating the same call can create another build', but nothing is wasted overall.

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

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

For a non-idempotent mutation with no output schema, the description omits what a successful call returns (build-run identifier for follow-up polling via get_build_issues/get_build_logs) and any authentication or permission requirements. The cancellation limitation is a strong addition, but the picture remains incomplete for an agent planning a full build-then-inspect loop.

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 80%, so the schema does the heavy lifting (buildRunId, pullRequestId, sourceBranchOrTagId are well documented). The description adds nothing about parameters, and workflowId – the sole required field – carries no schema description to compensate.

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

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

States a specific verb and resource ('Start exactly one new Xcode Cloud build') and pins the scope to a single build run. No sibling tool starts builds, so the agent can disambiguate immediately from list_workflows, get_build_logs, or update_workflow_* without opening a 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 never says when to call this versus other tools, nor what preconditions must hold (e.g. the workflow must exist and be enabled via set_workflow_enabled, or a workflowId must be obtained from list_workflows). The repetition caveat hints at usage but no genuine when-to-use guidance is offered.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses the destructive replace semantics (existing actions not included are dropped), which is the most important trait here, but says nothing about permissions, ordering, validation failures, or whether the call is atomic.

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

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

Two tight sentences, zero filler, with the replace-the-whole-array semantics front-loaded before the usage caveat.

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

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

For a mutation tool with no annotations, no output schema, and a complex nested action schema at 0% description coverage, the definition omits the action object shape, required fields, failure behavior, and any safety/permission context. It is under-specified relative to the tool's complexity.

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

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

Schema description coverage is 0% for both parameters, and the nested action objects (name, actionType, scheme, platform, destination, testConfiguration, buildDistributionAudience) are entirely undocumented. The description only gestures at the 'actions array' and adds no field-level meaning or format guidance, so it fails to compensate for the coverage gap.

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

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

States a specific verb ('replace') and resource ('workflow actions array'), and the word 'full' plus 'final desired action list' signals this is a wholesale replacement rather than a patch. It is distinguishable in spirit from update_workflow_general/update_workflow_start_conditions, but it never names or contrasts with any sibling, leaving the differentiation to inference.

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

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

Provides a genuine selection condition: use this 'only when the caller intends to send the final desired action list,' which implicitly excludes incremental/partial edits. It stops short of naming the alternative tool for partial updates, so the guidance is clear but not routing-complete.

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

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

The description indicates mutation ('update') but does not disclose side effects, required permissions, or behavioral nuances (e.g., whether other fields are reset). With no annotations, the description carries full burden but provides minimal insight beyond the operation.

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

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

The description is a single sentence, concise and to the point. It could be slightly more structured but wastes no words.

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

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

For a mutation tool with no annotations, no output schema, and 4 parameters (one required), the description is too sparse. It lacks information on return values, error conditions, and dependencies, leaving the agent underinformed.

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 mentions three of four parameters (name, description, clean) but omits the required workflowId. It does not explain what 'clean' means or any constraints. Partial but insufficient.

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 'update' and the resource 'workflow' with the qualifier 'general' fields, listing specific examples. It distinguishes from sibling tools like update_workflow_actions which update more specific fields.

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

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

No guidance on when to use this tool versus alternatives (e.g., update_workflow_actions, update_workflow_start_conditions). The description does not mention prerequisites, limitations, or when not to use it.

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

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

The description reveals that passing null removes a condition, which is useful behavioral information. However, it fails to disclose other important behaviors such as whether conditions are additive, what happens on errors, or the need for specific permissions, especially given the absence of annotations.

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

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

The description is very concise with two sentences and no fluff. It efficiently communicates the core action and a key detail (null removal). However, given the tool's complexity, it could benefit from slightly more structured detail without losing conciseness.

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

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

For an 8-parameter tool with no output schema and no annotations, the description is woefully incomplete. It omits information about required condition object structures, the effect of combining conditions, and what the response indicates. The agent lacks enough context to use the tool reliably.

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

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

The description does not explain the meaning of any of the 8 parameters beyond the null removal behavior. With 0% schema description coverage, the agent must guess what each condition object represents (e.g., tag, branch, scheduled), which is a significant 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 uses the specific verb 'update' and clearly identifies the resource as 'workflow start conditions'. It also distinguishes from sibling tools like update_workflow_actions and update_workflow_general by specifying a unique scope.

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 update_workflow_general. It lacks context about prerequisites, use cases, or when not to use it, forcing the AI to infer 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.