Codemagic MCP by usefulapi

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

Annotations already declare destructiveHint=true, and the description adds only the REST endpoint path (POST /builds/{id}/cancel), which is largely redundant. It does not disclose reversibility, idempotency, behavior when the build is not running, or auth requirements.

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

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

Two short sentences, fully front-loaded with the action and target, and the endpoint reference is compact. 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?

For a one-parameter mutation with no output schema and an annotation covering its destructive nature, the description supplies enough to invoke it correctly. Failure-mode and irreversibility details are the only minor omissions.

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

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

Schema description coverage is 100% and the single buildId parameter is fully documented in the schema. The description's 'by id' merely echoes the schema, so the baseline of 3 applies.

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

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

States a specific verb and resource ('Cancel a running build') and scopes it by id, so the agent can immediately distinguish it from siblings like codemagic_start_build or codemagic_get_build. It does not explicitly name those siblings, which is the only thing keeping it from a 5.

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

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

No explicit when-to-use or when-not-to-use guidance and no alternatives referenced. The qualifier 'running build' hints at a precondition but is descriptive rather than an instruction, leaving the agent to infer the applicable state.

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 only supply destructiveHint=true, so the description adds useful behavioral color by disclosing that the resulting URL is public and time-limited. It stops short of stating the security implication (the artifact becomes accessible to anyone holding the link) or what happens at expiry, which is the key thing an agent should surface for a destructive-hinted 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 tight sentences, front-loaded with the action and scope, with no filler. The trailing REST endpoint line is mildly redundant with the name but genuinely useful for API-mapping agents, so it still 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?

Two required, fully-described parameters, no nesting, no enums, and the operation is simple enough that the description plus schema is nearly sufficient. With no output schema, it would ideally state that the return value is the URL string, but that omission is minor.

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

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

Schema description coverage is 100%, so both secureFilename and expiresAt (UNIX seconds) are already fully documented in the schema. The description mentions the secure filename concept but adds no format or constraint detail beyond it, so the baseline of 3 is appropriate.

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

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

States a specific verb and resource ('Create a public ... download URL for a build artifact') and even names the API endpoint, so the action is unambiguous. However, it never distinguishes itself from the near-identical sibling codemagic_get_artifact_download_url, which is the one case where an agent could easily pick the wrong tool.

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

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

The parenthetical '(shareable, time-limited)' implies the use case of generating a link to hand to a third party, so usage is inferable. But there is no explicit when-to-use or when-not-to-use guidance and no mention of the sibling that returns a non-public download URL, leaving the routing decision 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 declare readOnlyHint=true, so the read-only safety profile is covered. The description adds the underlying REST route, which is mild context, but says nothing about behavior on a missing/invalid id or any auth/rate-limit considerations.

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 with zero filler, and the core action is front-loaded before the REST reference. Nothing could be cut without losing information.

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

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

For a trivial single-parameter read with readOnlyHint coverage, the description is nearly sufficient. There is no output schema, so a brief note on what the returned application object contains would have closed the remaining gap.

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

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

Schema coverage is 100% and there is only one parameter (id) already documented as 'The application id.' in the schema. The description adds no format, source, or sourcing hint for the id, so the schema does all the work.

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

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

States a specific verb (get) and resource (a single application by id), with the REST endpoint GET /apps/{id} as a concrete anchor. The word 'single' implicitly distinguishes it from the sibling codemagic_list_applications, but that sibling is never 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?

Usage is only implied: 'by id' tells the agent it needs an id, but there is no explicit when-to-use statement, no mention of when to prefer list_applications, and no guidance on what to do when the id is unknown or invalid.

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 readOnlyHint=true already covering the safety profile, the description adds that the URL is authenticated, which hints at permission requirements. It does not say whether the URL expires, how long it is valid, or whether it requires an API token on use, which are the practically important traits for a download-URL 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 tight sentences with the action front-loaded and the REST endpoint appended as useful reference; no filler 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?

For a one-parameter read tool with annotations covering safety and no output schema, this is nearly complete. Noting URL validity/expiry behavior would have closed the last gap, but nothing needed to invoke the tool is missing.

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

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

Schema description coverage is 100% and the single parameter is fully documented, so baseline is 3. The description's parenthetical about the filename coming from a build's artifacts list repeats what the schema already states rather than adding new syntax or format detail.

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: 'Get an authenticated download URL for a build artifact by its secure filename.' The word 'authenticated' implicitly contrasts with the sibling codemagic_create_artifact_public_url, but that sibling is never named, so differentiation is left to inference.

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

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

The description explains where the secureFilename comes from ('from a build's artifacts list') but gives no when-to-use condition and never mentions the obvious alternative, codemagic_create_artifact_public_url, which also produces an artifact URL. An agent has to guess which of the two URL tools applies.

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 readOnlyHint annotation already establishes this as a safe read. The description adds modest value by stating the response includes build status and by disclosing the underlying REST call (GET /builds/{id}), but says nothing about what happens on a missing/invalid build id or about any error behavior.

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

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

Two short sentences, both front-loaded with the essential information: what it returns and the endpoint backing it. Nothing is padded.

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

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

There is no output schema, so the description carries some burden for describing the return value, and it only mentions status. For a simple single-entity fetch this is adequate but not fully informative about the build object's contents.

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

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

Schema description coverage is 100% for the single buildId parameter, so the schema already carries the semantics. The description confirms the id is the lookup key but adds no format or source detail beyond that, so the baseline 3 applies.

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

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

States a specific verb and resource (get a single build by id) and clarifies the returned content includes status. It implicitly differentiates from the list-oriented sibling codemagic_list_builds, though it never names the 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?

No when-to-use guidance, no prerequisites, and no comparison to siblings such as codemagic_list_builds or codemagic_get_application. The 'by id' phrasing hints at the required input but gives the agent no routing logic.

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, so the safety profile is covered. The description adds value by naming the return fields and the underlying REST endpoint (GET /apps), but says nothing about pagination, result limits, or account scoping behavior for large app lists.

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

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

Two compact sentences: the purpose and return fields come first, with the REST endpoint as a trailing reference. Every word earns its place with no 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?

With no parameters and no output schema, the description usefully compensates by listing the fields returned. It is essentially complete for a simple zero-arg list tool, though pagination behavior for an unbounded list is left unstated.

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

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

The tool takes zero parameters, so there is nothing to disambiguate and the baseline of 4 applies. The description does not need to explain any argument 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?

States a specific verb+resource ("List all applications in the Codemagic account") and enumerates the returned fields (ids, names, workflow ids), which distinguishes it from codemagic_get_application. It never names the singular sibling or the boundary between them explicitly, so it stops short of full sibling 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 word "all" hints that this is an unfiltered enumeration, but there is no statement of when to use this versus codemagic_get_application for a single app, nor any prerequisites or exclusions. Usage is only weakly 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?

readOnlyHint=true already establishes the safe, non-mutating profile, so the description's burden is lighter. It adds only the REST endpoint (GET /builds), confirming the read semantics, but discloses nothing about pagination, default result limits, or ordering — real gaps for a list endpoint.

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

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

Two short sentences with the purpose and filters front-loaded and no filler. The trailing 'Codemagic REST: GET /builds' clause is mildly useful for doc cross-referencing but does not add much to an agent's decision.

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-required-parameter list tool with no output schema, an agent still needs to know result size, pagination, and default ordering before calling it. None of that is present, though annotations carry the safety profile.

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

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

Schema description coverage is 100%, so all three filter parameters are already documented in the schema. The description names the same filters without adding format, matching semantics, or combination behavior, so it earns the baseline, not more.

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

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

States a specific verb and resource ('List builds') and enumerates the three optional filter dimensions. It is clearly distinguishable from codemagic_get_build by the plural resource, but it never explicitly contrasts itself with that sibling or with codemagic_list_applications.

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 sentence describes which filters are available but gives no guidance on when to call this instead of codemagic_get_build, nor any prerequisites, ordering, or result-size caveats. Usage is only weakly implied by the verb 'List'.

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

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

With readOnlyHint=true already covering the safety profile, the description adds the returned field set and the underlying REST endpoint, which gives the agent confidence this is a plain filtered read. It stops short of disclosing pagination, ordering, or empty-cache behavior.

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

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

Two tightly packed sentences with the resource scope front-loaded and the endpoint mapping appended for orientation. No filler 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?

For a single-parameter read tool with annotations present and no output schema, the description covers the essentials and even lists the returned fields, which compensates for the missing output schema. Minor gaps remain around pagination and auth.

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

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

Schema coverage is 100% and appId is already described there, so the description adds nothing new about the parameter beyond implying it identifies the application. Baseline 3 applies when the schema does 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?

States a specific verb and resource ('List the build caches for an application') and enumerates the returned fields (id, size, last used, workflow). This clearly distinguishes it from siblings like codemagic_list_applications and codemagic_list_builds.

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

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

Usage is implied by the name and the 'for an application' scope, but there is no explicit when-to-use statement or prerequisite note (e.g. that the app must exist or that caches reflect past builds). No alternatives are named, though none of the siblings overlap in purpose.

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 supply only destructiveHint=true, so the description should carry behavioral context, but it adds only the REST endpoint (POST /builds), which merely restates that this is a write. It discloses nothing about side effects (consumed build minutes/instances), required permissions, concurrency or rate limits, or whether a branch and tag can both be set.

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

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

Three short clauses, front-loaded with the action, then the required parameters, then the optional set, plus the endpoint. No filler; every sentence contributes.

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 output schema and sparse annotations, the definition covers what must be passed but omits consequences of the call: no mention of the returned build identifier (needed for later polling via codemagic_get_build), auth requirements, or side effects. Adequate but with clear gaps.

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

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

Schema description coverage is 100%, so the schema already documents all seven parameters including the branch/tag alternative and instanceType examples. The description only restates the required pair and lists the optional fields, adding no format, constraint, or precedence detail beyond the schema. Baseline 3 applies.

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

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

States a specific verb and resource ('Start a new build for an application workflow') and identifies the two required identifiers, so the agent knows exactly what action is performed. It doesn't explicitly name the sibling it contrasts with (e.g. cancel_build), but the action is unambiguous.

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

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

The description says what is required and what is optional, but gives no when-to-use/when-not guidance relative to alternatives like codemagic_list_builds or codemagic_get_build, and no prerequisites (auth scope, whether the app/workflow must exist first). Usage is only weakly implied by the purpose sentence.

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