The Deployer

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

Beyond the annotations (readOnlyHint=true, destructiveHint=false), the description explicitly confirms the read-only nature ('changes nothing'), specifies the external dependency (no API key), sets a time expectation (up to a minute), and explains the asynchronous result retrieval via check_id. This gives an agent a clear operational model without contradicting any annotation.

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 well-structured with the purpose front-loaded and supporting details following logically. It is a multi-clause sentence, but each part adds distinct value (scope, outputs, non-destructive behavior, auth prerequisites, timing). No superfluous content; only minor verbosity from the long list of outputs.

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 two parameters, no output schema, and moderate operation complexity, the description is complete. It tells the agent what the tool returns (services, missing items, fixes, env vars, cost across four providers), how to handle long-running checks, and the inputs needed. An agent can call this tool correctly with no missing behavioral or output expectations.

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

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

With 100% schema description coverage, both parameters are already documented. The description adds valuable context by explaining that repo can be a path or URL and links check_id to the polling workflow ('if it's still running, call again...'). This goes slightly beyond the schema by clarifying how the parameters interact in practice.

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 clear verb ('Checks'), a specific resource ('public GitHub, GitLab or Bitbucket repository'), and a concrete goal ('will deploy'). It enumerates the exact outputs (services, missing items, env vars, cost across providers) and establishes a non-destructive scope ('Reads the code and changes nothing'), making its intent unambiguous and distinct from sibling tools like plan_deploy or redeploy.

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 offers solid contextual guidance: it states the tool applies to public repositories, requires no API key, and explains the polling pattern ('if it's still running, call again with the check_id it returned'). However, it does not explicitly state when to prefer this over alternatives (e.g., plan_deploy) or when not to use it, leaving some room for 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?

Goes beyond the annotations by disclosing that secrets are removed, that lines arrive newest-last, that output mixes build and app logs, and that an API key is required. Those are real behavioral facts the readOnly/idempotent hints 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?

Five short sentences, each earning its place, with the core purpose front-loaded. Slightly fragmented (e.g., 'Changes nothing. Needs an API key.') but no waste.

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

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

With no output schema, the description usefully explains what the returned lines represent and their ordering. Auth need and redaction are covered, leaving little an agent would need to ask before calling.

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 four parameters. The description only restates errors_only and the newest-last ordering, adding no syntax or format 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 ('Shows the log of a project's latest deployment, or of a given deployment') with scope. It does not explicitly differentiate itself from siblings like status, but the purpose 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?

It clarifies the two selection modes (latest vs. a given deployment) and when to use errors_only, but offers no explicit when-not guidance and never names an alternative sibling such as status.

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 cover the read-only and non-destructive nature, and the description reinforces this with 'Changes nothing.' It adds material behavioral context, including the need for an API key and that the tool gathers connected cloud/git accounts, existing projects, and next steps with links. This goes beyond the structured 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?

The description is compact and front-loaded with the main activity in the first few words, then provides the key informational steps and important caveats. The long central sentence is dense but each clause adds useful information, and the 'Changes nothing' and API key requirements are clear separate statements. It could be slightly more structured with breaks, but it avoids boilerplate.

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

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

With no output schema, the description appropriately names most relevant output components: connected accounts, existing projects, next steps, and links. It also gives prerequisite context such as the API key. Exact response formatting and round-trip behavior are not specified, but the tool is conceptually simple enough that the described contents are reasonably complete for call selection and high-level use.

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

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

The input schema has 100% description coverage for both parameters, so the schema already carries the parameter semantics. The description does not add important extra guidance around how `repo` or `cloud` should be used, though it does mention accounts at a high level. Baseline 3 applies because the schema is already self-explanatory.

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 single purpose: plan a deploy without executing it. It names the resource (repository), the user's accounts/project, and the expected informational output, and it distinguishes itself from check_repo and the other siblings by emphasizing planning rather than deployment or changes.

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 use case is clear: use this when the user wants deployment planning for a repo, with checks and next steps, and it needs an API key. It also implicitly differentiates itself from check_repo by saying it checks the repo 'like check_repo' then goes further with plans, links, and account/project context. It does not explicitly say 'don't use this for actual deployment,' but 'Plans' and 'Changes nothing' make that evident.

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 destructive=true, readOnly=false, openWorld=false, and idempotent=false. The description adds important operational context beyond annotations: it changes a live app, requires user confirmation, takes a few minutes, needs an API key, and should be followed with status or logs. 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?

Front-loaded with the core action, then adds safety, scope, timing, and follow-up guidance in compact sentences. Every sentence earns its place and none repeat structured fields unnecessarily.

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 live-app operation with no output schema, the description covers impact, user confirmation, scope restrictions, duration, auth needs, and recommended follow-up. It is complete enough for an agent to call the tool correctly alongside its annotations.

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 optional project parameter is fully documented in the schema. The description does not add syntax, format, or selection detail beyond what the schema already provides, so the baseline of 3 is appropriate.

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

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

States a specific verb and resource: redeploy puts the latest code on a live project's branch online by pulling and restarting the app. It clearly distinguishes this from planning and follow-up tools by noting that status or logs should be used after, and that a first deployment happens in the app rather than through this 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?

Gives explicit when-to-use and when-not-to-use guidance: only for an already-live project, not for a first deployment, which starts in the app. It also says to confirm with the user first, follow with status or logs, and notes the API key requirement.

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 mark this as non-read-only)Skip; the description adds meaningful behavior: it never charges, requires an API key, and returns price, delivery promise, and a payment link. This goes beyond the structured hints and clarifies side effects and prerequisites.

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 dense and front-loaded with the core purpose, then quickly covers costs, API key requirement, and return values. Minor redundancy exists between 'Asks... the team' and 'Tells the team,' but each 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?

With no output schema, the description still covers return values, pricing behavior, authentication requirements, and available options. It is sufficiently complete for correct invocation, though it doesn't discuss error cases or asynchronous behavior.

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

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

The description explains the required 'offer' parameter's enum values with concrete scenarios, which is the most important parameter. 'note' and 'repo' are already described in the schema, so the description adds value where the schema is weakest.

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 specific actions: launch, launch_secure, and move, and explains each parenthetically. This clearly distinguishes the tool from the sibling self-service tools and states both the verb and the resource.

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: use this tool when the user wants The Deployer's team to perform a launch, secured launch, or migration. It doesn't explicitly mention when not to use it or name alternatives, but the purpose is distinct enough among the 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 declare readOnlyHint, idempotentHint, and destructiveHint, so "Changes nothing" largely repeats structured data. But the description adds a valuable non-annotated requirement: "Needs an API key." It also explains what information is returned, which goes beyond 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?

The description is short, front-loaded with the action and resource, and the API-key note is essential. The phrase "Changes nothing" is redundant with the annotations frod, but the overall structure remains tight and not bloated.

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 tool with one optional parameter)Skip? The description covers the core contract: scope, returned data, safety, and auth. However, it lacks detail on exact response shape or edge cases like project-not-found, and "where that is" is slightly vague; these are minor gaps given the tool's simplicity.

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

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

The sole optional parameter is already fully described in the schema, including accepted forms (id, name, repository) and the leave-out behavior. The description only says "or one project," adding no new parameter-level meaning, so the baseline of 3 applies.

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

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

The description uses a specific verb and resource: "Lists the user's projects on The Deployer," and enumerates the output fields (live status, addresses, latest deployment). This clearly distinguishes it from sibling tools like plan_deploy or redeploy, and it covers both the list-all and single-project modes.

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 that this is the read-only status tool, and it adds the requirement "Needs an API key." However, it never explicitly says when to use this over siblings such as logs or check_repo, nor does it describe when to prefer a sibling instead. The usage context is clear but not exclusionary.

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