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

No annotations are provided, so the description carries full burden for behavioral disclosure. The description does not state whether the operation is reversible, what side effects occur (e.g., if a queued deployment is removed entirely), or whether any confirmation or rollback is possible. The only hint is the "[WRITE]" prefix indicating mutation, but deeper behaviors remain opaque.

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 extremely concise at a single phrase. However, the "[WRITE]" prefix is a useful semantic marker that adds structure without redundancy. Every element earns its place. It could be slightly more informative while remaining concise, but as it stands it is not wasteful.

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

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

Given the tool's simplicity (single parameter, no output schema), the description is minimal but adequate for basic invocation. However, it fails to explain important context like what happens after cancellation, whether the operation is synchronous or asynchronous, or how to verify the result. For a cancellation tool, these details matter for an AI agent's execution confidence.

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 schema provides 100% coverage for the single parameter 'uuid', including a description that says "UUID of the deployment to cancel". The description does not add any additional meaning beyond what the schema already provides, such as how to obtain the UUID or any format constraints. Given full schema coverage, the baseline is 3, and the description does not exceed 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 starts with "[WRITE]" to signal the operation type, and then uses a specific verb and resource: "Cancel a running or queued deployment". This clearly states what the tool does and distinguishes it from other deployment tools like coolify_trigger_deploy or coolify_get_deployment. However, it does not explicitly differentiate from coolify_restart_application (which also affects running state), but the resource is clearly deployments.

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. It does not mention prerequisites (e.g., needing the deployment UUID from a tool like coolify_list_deployments) or constraints (e.g., only works on running or queued deployments). Without such guidance, an AI agent may attempt to cancel a deployment that has already completed or fail to understand the required input context.

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

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

With no annotations provided, the description carries the burden and does well: it flags the [WRITE] classification and explains the non-obvious reason ('Changes nothing, but the API requires write ability'), preventing an agent from assuming this mutates state. It falls short of describing what the call returns or how a failed check surfaces.

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 [WRITE] tag and the core purpose are front-loaded, and every clause (version requirement, non-mutating reassurance) adds information. No filler.

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

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

For a two-parameter validation call with no output schema, the description covers purpose, side-effect profile and version gating. It omits what a successful versus failed check yields, which is the one gap an agent would still want closed.

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%, with the registry parameter carrying a format example ('ghcr.io or docker.io'). The description adds nothing beyond the schema, so 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 ('Check') and precise resource ('the stored login of a server for a Docker registry'), plus a version constraint (v4.4+). It is distinguishable from login/logout/list siblings by implication, but never names them explicitly.

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 phrasing 'still works' implies this is a validation step after a login has been stored, but the description never states when to call it versus coolify_login_server_registry or coolify_list_server_registries, nor any prerequisite that a registry entry must already exist.

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

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

No annotations are provided, so the description must carry the full behavioral burden. It discloses that this is a write operation via "[WRITE]" and "Create," but does not explain side effects, permission requirements, how instant_deploy behaves, or what happens across the different source types.

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 one short sentence with a useful "[WRITE]" prefix and is front-loaded with the core action. It contains no wasted language, though "from various sources" is vague enough to reduce precision slightly.

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 complex write tool with 19 parameters, no annotations, and no output schema, the description is too minimal. It omits source-type distinctions, required field relationships, and operational consequences, leaving the schema to carry nearly all of the explanatory load.

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 19 parameters including required fields, enums, and source-specific requirements. The description adds no parameter-level meaning beyond the vague phrase "from various sources," 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?

The description states a clear verb and resource: "Create a new Coolify application." The "[WRITE]" tag reinforces the operation type. However, it does not explicitly distinguish this tool from sibling alternatives such as coolify_update_application or coolify_delete_application, leaving that distinction implicit.

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

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

There is no guidance on when to use this tool versus alternatives, nor are prerequisites such as needing a server UUID, project UUID, and environment name called out in prose. The create intent is inferable from the name, but no explicit usage context or exclusions are 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 are provided, so the description carries the full behavioral burden. It discloses only that this is a write operation; it says nothing about required permissions, side effects, idempotency, or what happens to existing tasks.

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

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

The description is a single, front-loaded sentence with no wasted words. Its brevity contributes to conciseness, though the resulting under-specification is penalized elsewhere.

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 and no output schema, the description is far too thin. It does not explain creation behavior, permission requirements, response format, or how this interacts with application deploys or existing scheduled tasks.

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 seven parameters including uuid, command, frequency, timeout, and enabled are already documented in the input schema. The description adds no parameter meaning beyond that baseline.

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

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

The description states a specific verb ('Create') and resource ('scheduled task') scoped to a Coolify application, which distinguishes it from the sibling service scheduled-task tool. It is clear but does not explicitly name alternatives or contrast with update/list/delete scheduled-task siblings.

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

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

There is no guidance on when to use this tool versus alternatives, no prerequisites, and no exclusions. The only usage signal is the implied '[WRITE]' prefix, which is not sufficient to route an agent among the many 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?

With no annotations, the description carries the full burden. The '[WRITE]' tag and 'Add' signal mutation, but nothing is said about prerequisites, side effects, reversibility, or what happens with different storage types. This is a thin disclosure for a create 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?

A single, front-loaded sentence with the '[WRITE]' marker and a clear action/resource pair. There is no filler or repetition of schema details, making it efficient and easy to scan.

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

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

The tool has nine parameters and conditional field interactions, and there is no output schema or annotations. However, the schema's per-field descriptions are unusually thorough, covering file-only fields, unsupported host_path, and requirements like fs_path with is_directory/is_host_file. The description itself is too sparse to explain return values or prerequisites, but the overall definition is adequate for invocation.

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

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

Schema description coverage is 100%, so the schema already documents all nine parameters, including conditional requirements like name being required for persistent storages. The description itself adds no parameter-level meaning, which is acceptable given the rich schema, but it also doesn't highlight the most important conditional logic.

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 '[WRITE]' and uses the specific verb 'Add' with a concrete object ('persistent or file storage mount') and target ('Coolify application'). This clearly distinguishes it from sibling storage tools for services/databases and from update/list/delete storage tools.

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

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

The verb 'Add' and the phrase 'to a Coolify application' imply this tool is for creating new storage mounts on an application, as opposed to updating or listing them. However, it does not explicitly name alternatives or state when not to use it, so the guidance is only implicit.

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

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

No annotations are provided, so the description carries the full behavioral burden. The '[WRITE]' marker confirms mutation, but the description does not mention required permissions, side effects, whether deployment happens immediately, or what happens when dependencies are missing. For a create operation with 14 parameters and no annotations, this is a significant 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 a single front-loaded phrase with no waste, but it is under-sized for a complex mutation with 14 parameters and nested configuration. It is concise without being appropriately complete.

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 a 14-parameter creation tool with nested type_config, no annotations, and no output schema, the description is too thin. It does not explain required relationships, engine-specific configuration expectations, or post-creation behavior, leaving critical context to the schema alone.

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 14 parameters, including the enum type and nested type_config, are documented in the schema itself. The description adds no parameter meaning beyond that, which meets the baseline for high-coverage schemas but does not exceed 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 states a clear verb ('Create') and resource ('Coolify database'), and the '[WRITE]' tag signals mutation. Its specificity distinguishes it from siblings such as coolify_create_application and coolify_create_service, though it adds no scope detail beyond the noun.

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

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

There is no guidance on when to use this tool versus alternatives like coolify_import_database, nor any prerequisites such as an existing server, project, or environment. The agent is left to infer usage entirely from the tool name.

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 does disclose that this is a write operation and that backup_now triggers an immediate execution in addition to scheduling. It omits permissions/auth requirements, what happens to an existing schedule, and any side effects of enabling S3 or retention options.

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

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

Two sentences, mutation marker front-loaded, required parameter flagged, and the optional immediate-run behavior called out immediately after. Nothing is wasted.

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 16-parameter mutation with no annotations, 31% schema coverage and no output schema, the description covers only two fields and says nothing about return values, failure behavior, or how the many retention/S3 knobs interact. It is well short of what an agent needs to call this safely.

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 only 31% across 16 parameters, so the description needs to compensate and does not. Its two hints (frequency is required, backup_now runs immediately) merely restate the schema's own field descriptions, while enabled, save_s3, timeout, dump_all, databases_to_backup and all six retention parameters remain undocumented anywhere.

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

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

States a specific verb and resource ('Create a database backup schedule'), which separates it from the sibling update_database_backup, delete_database_backup and list_database_backups. It does not explicitly name those siblings, but the create-schedule framing 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 '[WRITE]' tag and '(frequency required)' imply this is the mutation path for setting up a schedule, and backup_now is explained. However, it never says when to pick this over coolify_update_database_backup or how it relates to coolify_run_database_storage_backup, so the agent must infer the boundary.

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

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

With no annotations provided, the description bears the full burden of behavioral disclosure. It only includes a '[WRITE]' tag implying mutation but does not describe what happens on success (e.g., returns the created variable?), error conditions, idempotency (does it overwrite existing keys?), or authentication/rate-limit considerations. The behavioral information is minimal.

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

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

The description is a single sentence plus a '[WRITE]' tag, making it very concise. However, it lacks structure (e.g., no separate sections or additional details). While it is not verbose, a few more words could improve clarity without sacrificing 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?

The tool has 8 parameters, no output schema, and is a mutation operation. The description only says 'Create a new environment variable for a Coolify database' without explaining return values, error scenarios, or any side effects. Given the complexity (multiple boolean flags, optional comment), this is notably incomplete.

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

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

Schema coverage is 100%, so baseline is 3. The description does not add any additional meaning beyond the schema; it merely restates the overall action. The schema already fully describes each parameter with names, types, and descriptions. The description adds no extra semantic value.

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 ('Create') and resource ('environment variable for a Coolify database'), and the '[WRITE]' prefix further clarifies it's a mutating operation. It distinguishes itself from sibling tools like coolify_delete_database_env (delete), coolify_update_database_envs_bulk (bulk update), and coolify_create_env (generic env creation) by specifying it's database-specific.

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 like coolify_create_env or coolify_create_service_env. It does not mention prerequisites (e.g., needing a database UUID), nor does it explain when not to use it. The description lacks any usage context.

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

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It includes '[WRITE]' hinting at mutation, but does not mention prerequisites, side effects, reversibility, or any consequences of the operation. For a create operation, this is minimal disclosure.

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

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

A single, front-loaded sentence with no unnecessary words. The [WRITE] marker and the action are immediately clear, and every word earns its place.

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

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

The description is minimal but sufficient for a create operation when the schema already details parameters. However, it does not explain the difference between storage types or conditional parameter usage (which the schema handles), and it lacks guidance on usage context beyond the database scope.

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%, so the schema fully documents all parameters with descriptions. The description does not add any parameter-specific meaning beyond what the schema provides, meeting the baseline for tools with full 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?

The description states a clear action: 'Add' a 'persistent or file storage mount' to a 'Coolify database'. This precisely identifies the verb, resource, and scope, distinguishing it from similar storage tools for applications and services (e.g., coolify_create_application_storage). It is specific and 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 implies database usage but does not explicitly mention alternative tools or conditions for when to use this over coolify_create_application_storage or coolify_create_service_storage. No exclusions or alternatives are given, leaving the agent to infer context from the tool name and sibling list.

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

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

No annotations are provided, so the description carries full burden for behavioral traits. The description only states 'Create a new environment variable' but does not disclose what happens if a variable with the same key already exists (overwrite, error, or skip), whether the operation is idempotent, or any authorization requirements. The '[WRITE]' tag is redundant with 'Create'. For a mutation tool, this lack of behavioral detail is a significant 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 a single sentence, front-loaded with the action. It is concise and avoids fluff. However, the '[WRITE]' prefix is redundant because 'Create' already implies a write operation. Still, it is appropriately sized for a straightforward tool, earning a 4 rather than a 5 due to the slight 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 the tool has 8 parameters (3 required), no output schema, and no annotations, the description is incomplete. It does not explain the tool's behavior regarding duplicates, the effect of boolean flags (is_literal, is_preview, etc.) beyond the schema, or what the return value is. The presence of many related env sibling tools (create/update/delete for apps, databases, services) calls for more context to prevent misuse, but the description provides none.

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 each parameter has a meaningful description (e.g., 'key' says 'Variable name (e.g. DATABASE_URL)', 'uuid' says 'UUID of the application'). The tool description adds no additional meaning beyond the schema. With high schema coverage, the baseline is 3; the description does not elevate it further.

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 ('Create a new environment variable') and the resource ('for a Coolify application'). The '[WRITE]' prefix reinforces the action. This distinguishes it from sibling tools like coolify_list_envs (list), coolify_update_envs_bulk (update bulk), coolify_delete_env (delete), and coolify_create_database_env (creates for database, not application). The purpose is specific and 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 gives no explicit guidance on when to use this tool versus alternatives (e.g., coolify_create_database_env, coolify_create_service_env). It does not mention that this tool is specifically for application environment variables, nor does it provide prerequisites, exclusions, or context for when it should be chosen over other env creation tools. The agent must infer from the tool name and siblings, which is insufficient.

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 states '[WRITE]' indicating a mutation, but does not describe what happens after creation (e.g., whether it's automatically activated, or if it triggers any side effects). The description lacks details on permissions, idempotency, or error cases.

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 that is concise and front-loaded with the '[WRITE]' marker. Every word is necessary, but it could be slightly more descriptive 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?

Given the tool has 2 required parameters, no output schema, and no annotations, the description is too sparse. It does not explain the response format, potential errors, or the relationship between environments and projects. The low complexity is offset by the lack of behavioral 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?

Both parameters are described in the schema (100% coverage), so the baseline is 3. The description does not add any additional meaning beyond what the schema already provides. The schema documents 'name' as 'Environment name (e.g. 'staging', 'production')' and 'project_uuid' as 'UUID of the project', which is sufficient.

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 starts with '[WRITE]' to indicate a mutation, and clearly states 'Create a new environment in a Coolify project'. The verb 'create' and resource 'environment' are specific. However, it does not differentiate from sibling tools like 'coolify_create_project' or 'coolify_create_application', which also create resources, but the target resource is distinct enough.

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. There is no mention of prerequisites (e.g., project must exist) or when not to use it. Siblings like 'coolify_list_environments' or 'coolify_get_environment' are not referenced for context.

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

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

No annotations are provided, so the description must fully convey behavioral traits. It only states 'create' but does not mention if the operation is irreversible, requires special permissions, or has side effects like API rate limits. For a write operation, this is insufficient.

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 brief and front-loaded. It does not waste words, but could be improved with a bit more 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?

Although there is no output schema, the tool has only one required parameter, so completeness is partially covered. However, the description does not explain what happens after creation (e.g., does it return an app ID?), and the nested object (custom_fields) may confuse agents without further guidance.

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 documents both parameters. The description adds no additional meaning beyond what the schema provides, such as how the 'name' might be validated or what 'custom_fields' typically expects. Baseline 3 is appropriate.

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

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

The description states the tool creates a new GitHub App integration in Coolify, which is clear for a single purpose. However, it does not differentiate from sibling tools like coolify_update_github_app or coolify_delete_github_app, which is a minor gap.

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 creating a GitHub App via the Coolify UI or using other integration tools. No prerequisites or context are 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?

With no annotations, the description usefully discloses that this is a WRITE operation and that Coolify validates the token against the provider before saving. However, it does not state required permissions, whether the token can be retrieved later, failure behavior, or other side effects.

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, front-loaded with the [WRITE] marker and the core action. There is no redundant or wasted text.

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

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

The description covers purpose, write behavior, validation, and version, which is useful. But with no annotations and no output schema, it leaves gaps around authorization requirements, post-creation behavior, and what the operation returns.

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

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

Schema coverage is 75%, and the schema itself describes token formats and provider-specific metadata fields in detail. The description names the providers but adds little parameter-level meaning beyond the schema, so baseline adequacy is appropriate.

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

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

The description states a specific verb and resource: "Store a Doppler, Infisical, or HashiCorp Vault token," with team scope and version context. It is clear, though it does not explicitly distinguish this tool from sibling secret-management operations such as coolify_update_application_secret_manager.

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 secret-manager token context and the Coolify v4.4+ note, but there is no explicit when-to-use guidance, no when-not-to-use guidance, and no named alternatives. The agent can infer the intended context but is not routed against close 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?

With no annotations, the description must fully disclose behavior. It only states the creation action but does not explain side effects (e.g., behavior on duplicate name, key validation, persistence, or return value). The '[WRITE]' prefix adds minimal transparency. Critical behavioral traits such as error conditions or idempotency are omitted.

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

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

The description is a single sentence with a useful '[WRITE]' prefix. Every word carries meaning and there is no redundancy. It is appropriately sized and front-loaded.

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

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

Given the tool's complexity (3 parameters, no output schema, no annotations), the description is insufficient. It does not explain expected return values, potential failure modes (e.g., duplicate name, invalid key format), or pre-conditions such as the key being unique. The agent lacks critical context to handle the tool robustly.

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%, so the baseline is 3. The description adds context that the key is used for server/application authentication, which complements the schema parameter descriptions. However, it does not elaborate on specific parameters beyond the schema.

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

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

The description clearly states the action ('Create') and the resource ('SSH private key') and its purpose ('for server/application authentication'). The '[WRITE]' prefix explicitly marks it as a write operation. It is distinct from sibling tools like 'coolify_update_private_key' and 'coolify_delete_private_key'.

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. For example, it does not mention that this is for adding a new key before associating it with a server, nor does it differentiate it from 'coolify_update_private_key' or 'coolify_delete_private_key'. No prerequisites or exclusions are given.

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

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

With no annotations provided, the description must disclose behavioral traits. 'Create' implies a mutation (write operation), but it doesn't mention whether the tool has side effects like auto-assigning IDs, creating default environments, or requiring specific permissions. There's no statement about the return value or 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?

The description is very short (one sentence fragment), which is concise but not necessarily well-structured. The '[WRITE]' prefix is unnecessary and adds clutter without value. It could front-load with a more informative verb phrase or omit the prefix entirely.

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 2 parameters, no output schema, no annotations, and vast sibling tools, the description is incomplete. It doesn't explain the project concept, confirm that projects are containers for applications/databases, or hint at the expected output (e.g., created project ID/name). An agent might not understand the role of this tool in the Coldify workflow.

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

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

Schema coverage is 100%, so the description's lack of parameter details is partially excused. The input schema already documents 'name' (required, project name) and 'description' (optional, project description). The description adds no additional meaning beyond what the schema provides, but the schema is self-sufficient.

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 the action ('Create') and resource ('a new Coolify project'), which is clear. However, the '[WRITE]' prefix is redundant with the verb 'Create' and doesn't help differentiate this tool from other creation tools like 'coolify_create_application' or 'coolify_create_database'. It's adequate but not explicit about what a 'project' is in Coolify's context.

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 usage guidelines are provided. The description does not mention when to use this tool over alternatives like 'coolify_update_project' or 'coolify_create_environment'. It also lacks context about prerequisites (e.g., whether a team or server must exist first) or that it's typically the first step before creating applications or databases within the project.

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 behavioral burden, yet it only discloses the SSH key requirement. It says nothing about required permissions, whether the server is validated/connected on creation, whether instant_validate triggers a remote SSH probe, what happens on duplicate IPs, or whether the operation is reversible.

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 single sentence is front-loaded with the action and contains no filler. It is arguably too terse for a nine-parameter mutation tool, but nothing in it is wasted.

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

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

For a write tool with no annotations, no output schema, and nine parameters, the description is far too thin. An agent gets no picture of side effects, prerequisite lookups (private key creation), or what the call returns, leaving meaningful 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 every parameter is already documented, including the deprecated is_build_server and server_role enum. The description adds no extra meaning (e.g., that private_key_uuid should come from coolify_list_private_keys), 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?

The description states a specific verb and resource ('Create a new Coolify server'), which cleanly separates it from siblings like coolify_update_server, coolify_delete_server, and coolify_list_servers by verb alone. It does not explicitly name or contrast with those siblings, so it stops short of 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?

Beyond the 'requires SSH private key' precondition, there is no guidance on when to choose this tool versus coolify_validate_server or coolify_update_server, nor any note about obtaining the key UUID via coolify_list_private_keys. The [WRITE] tag implies mutation but gives no workflow context.

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

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

No annotations provided, so the description must fully disclose behavioral traits. It states '[WRITE]' and 'one-click Docker Compose service', hinting at creation behavior, but lacks details on idempotency, validation steps, required permissions, or return value (no output schema). With zero annotation coverage and minimal description, the agent has insufficient context to anticipate side effects.

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?

At one short sentence, the description is concise with no wasted words. However, it could be slightly more informative without sacrificing brevity, e.g., by mentioning required resources (server, project) or that the service type must be one of the supported Docker Compose services. The '[WRITE]' tag is a helpful structural hint.

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 8 parameters (4 required), a nested 'custom_fields' object, no output schema, and dozens of sibling tools, the description is too minimal. It doesn't explain what constitutes a 'service' vs. an 'application' or 'database', what the consequence of 'instant_deploy' is, or how to obtain valid UUIDs for server, project, and environment. The agent lacks enough context to reliably invoke this tool.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds 'one-click Docker Compose service' context but does not elaborate on parameter semantics beyond what the schema already provides. For example, it doesn't clarify how 'custom_fields' or 'instant_deploy' interact with the overall creation flow. Coverage is high, so no penalty, but the description doesn't add significant value.

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 verb 'Create' and resource 'Coolify service', and specifies it's a 'one-click Docker Compose service', which distinguishes it from sibling tools like coolify_create_application or coolify_create_database. The prefix '[WRITE]' further clarifies the operation type.

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 (e.g., coolify_create_application for custom apps). The description implies usage for pre-packaged Docker Compose services, but does not explain which service types are valid or when to use this instead of coolify_update_service. No exclusions or prerequisites 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?

With no annotations provided, the description must fully disclose behavior. It correctly states this is a write operation but does not mention whether updating an existing key overwrites, what the return value is, whether the operation is idempotent, or any side effects (e.g., triggering a redeploy). The description does not contradict anything since there are no annotations, but it is insufficient for understanding behavioral implications.

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 that clearly states the action and target. It is appropriately concise with no wasted 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 tool that creates an environment variable with 8 parameters and no output schema, the description is minimally adequate. It tells the agent the basic action and target, but does not explain what happens after creation (e.g., does the service restart?), nor does it clarify the role of optional parameters like 'is_literal' or 'is_preview' beyond the schema. With no annotation support, more context is warranted.

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 all 3 required parameters have clear schema descriptions. The description adds only the tool-level context that this is an environment variable for a service, but does not add meaning beyond the schema. Since coverage is high, a 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?

The description starts with '[WRITE]' which signals it's a mutation, but then says 'Create a new environment variable for a Coolify service'. While 'Create' and '[WRITE]' are consistent, the description does not differentiate this tool from 'coolify_create_env' which does the same for applications, not services. Without specifying that this targets services, the agent may confuse it with the generic environment variable creation 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?

There is no guidance about when to use this tool versus alternatives like 'coolify_create_env' (for applications) or 'coolify_create_database_env'. The description does not mention prerequisites (e.g., the service must exist), nor does it specify when not to use it. This is a critical gap given the large number of 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?

With no annotations provided, the description carries the full burden. It includes a '[WRITE]' tag indicating a mutation, but gives no further behavioral details like required permissions, side effects, or whether the task is immediately enabled.

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

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

The description is a single, front-loaded sentence with zero waste. It efficiently conveys the core action and the '[WRITE]' tag adds a quick signal.

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 complexity of seven parameters and no annotations, the description is minimal. While the schema covers parameter details, the description could provide more context about the creation process, such as what a scheduled task entails or any post-creation effects.

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%, with all seven parameters well-documented. The description adds no extra parameter semantics, so the baseline score 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?

The description states a specific verb ('Create') and resource ('scheduled task') for a Coolify service, making the action clear. However, it does not explicitly differentiate from sibling tools like coolify_create_application_scheduled_task, though the tool name itself helps distinguish.

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

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

The description gives no guidance on when to use this tool versus alternatives, such as the application scheduled task creation. There is no mention of prerequisites, appropriate scenarios, or exclusions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only labels the operation as [WRITE] and states the resource type, but does not disclose side effects (e.g., whether existing mounts are affected), permission requirements, or reversibility. The description adds minimal behavior context beyond the explicit action verb.

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

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

One sentence with zero filler, front-loaded with the write indicator. Highly efficient and appropriately concise for a tool with a relatively clear action.

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

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

Given the tool has 10 parameters, conditional requirements (e.g., `name` required for persistent, `fs_path` for file), and no output schema or annotations, the description is far too sparse. It does not explain the relationship between parameters, required combinations, or behavioral expectations, leaving an agent with significant gaps when deciding how to invoke it correctly.

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

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

Schema coverage is 100%, so all parameters already have descriptions. The description itself adds no extra parameter semantics beyond indicating 'persistent or file storage mount', which echoes the `type` enum already present in the schema. Baseline 3 is appropriate because the schema handles full parameter documentation.

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

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

Description clearly states the action (Add) and the resource (storage mount to a Coolify service sub-resource), with specificity that distinguishes it from sibling tools operating on application or database storage. It is a precise verb-object construction.

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 alternative storage creation tools (e.g., coolify_create_application_storage or coolify_create_database_storage). The description does not mention prerequisites, constraints, or decision criteria for choosing persistent vs file storage.

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 clearly states the action is permanent and destructive with '[DESTRUCTIVE]' and 'Permanently', which is good. However, it does not disclose side effects like whether the deletion is irreversible, what happens to associated resources (e.g., if delete_volumes and docker_cleanup are false), or whether it requires confirmation via the 'confirm' parameter. The description partially compensates for missing 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 a single, front-loaded sentence with zero wasted words. The '[DESTRUCTIVE]' tag immediately conveys critical behavioral context, and 'Permanently delete a Coolify application' is precise and complete.

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 destructive nature and no output schema, the description does not explain what the return value is (e.g., success message or ID). However, the schema covers all parameters well, and the description clearly sets expectations for the operation's finality. A note about the confirmation parameter or return behavior would increase completeness, but it is adequate for a deletion tool with well-documented params.

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 with descriptions. The tool's description adds no additional parameter meaning beyond the schema's structured definitions. Baseline 3 is appropriate since 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?

The description uses a clear, specific verb ('delete') and resource ('Coolify application'), immediately stating the action's permanent nature with the '[DESTRUCTIVE]' prefix. This clearly distinguishes it from siblings like 'coolify_stop_application' (temporary halt) and 'coolify_delete_application_storage' (storage deletion only).

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

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

The description explicitly signals the destructive nature and permanence of the operation via '[DESTRUCTIVE]' and 'Permanently delete'. This implies careful consideration before use, though it does not explicitly state when not to use it (e.g., use 'coolify_stop_application' instead) or list any prerequisites (e.g., application must exist). The sibling list contains safer alternatives.

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

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

With no annotations, the description carries the full behavioral burden and does so well: it discloses the cascading effects (cancels deployments, removes containers, volumes and networks). It stops short of stating irreversibility or required permission scope, which for a destructive operation would be the remaining 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?

A single sentence with the destructive marker front-loaded and zero waste; every clause adds factual effect 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 3-parameter destructive tool with no annotations and no output schema, the description covers target and destruction scope adequately. The only missing context is irreversibility and permission requirements, which is a modest gap rather than a blocking one.

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 parameters (uuid, pull_request_id, confirm) are already documented, including the confirm flag for destructive operations. The description adds no further meaning about how uuid and pull_request_id combine to identify the target preview, 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 ('Delete') and resource ('a preview deployment') and immediately enumerates the cascade. It is unambiguously distinct from siblings like coolify_delete_application or coolify_update_application_preview.

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 '[DESTRUCTIVE]' tag implies caution, but the description never states when this should be used versus alternatives such as deleting/updating the parent application, nor when to avoid it. Usage is implied by the verb rather than explained.

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 tags '[DESTRUCTIVE]' and the confirm parameter's description ('Set to true to confirm this destructive operation') clearly disclose the destructive nature. Since no annotations are provided, the description carries the full burden and does so adequately for the safety aspect. However, it does not disclose other behavioral traits like idempotency, permission requirements, or side effects (e.g., whether cascading deletions occur).

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

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

The description is a single sentence with a useful '[DESTRUCTIVE]' prefix. It is concise and front-loaded with the warning. No extraneous words. Could be slightly expanded (e.g., mentioning the confirm parameter) without losing conciseness, but current form is 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 destructive operation with no annotations and no output schema, the description is too minimal. It does not explain what happens after deletion (e.g., success/failure response, silent removal), nor does it clarify the relationship between the two required UUIDs. The confirm parameter is mentioned in the schema but not reinforced in the description. More context would help the agent understand the full impact and flow.

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%—all three parameters (uuid, task_uuid, confirm) have descriptions in the schema. The tool description adds no additional information about the parameters beyond what is already in the schema. Thus, baseline 3 is appropriate; the schema already documents each parameter's purpose.

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 ('Delete') and the resource ('a scheduled task from a Coolify application'). The verb and resource are specific, and the name differentiates it from sibling tools for different resources (e.g., coolify_delete_application, coolify_delete_service_scheduled_task). However, it does not explicitly distinguish between similar scheduled task delete tools for different parent entities (applications vs. services).

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, such as when to choose delete over update or create. It does not mention prerequisites (e.g., the application must exist) or conditions under which deletion is appropriate. The confirm parameter implies caution, but the description lacks explicit 'when to use' or 'when not to use' context.

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

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

No annotations are provided, so the description must carry full burden. It marks the operation as '[DESTRUCTIVE]', which adds transparency about irreversibility. However, it does not disclose any other behavioral traits such as required permissions, side effects on the application, whether it warns or requires a confirm parameter (though schema has 'confirm' boolean), or potential impact on running applications.

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

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

The description is a single, clear sentence with the destructive flag front-loaded. Every word serves a purpose with no redundancy. Ideal length for a delete operation.

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

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

Given that there is no output schema and no annotations, the description could be improved by explaining what happens after deletion (e.g., storage is removed immediately, application may need restart). For a destructive operation with 3 parameters, the description is minimally adequate but lacks completeness regarding effects and confirmation flow.

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 three parameters ('uuid', 'storage_uuid', 'confirm') are already well-documented in the schema with types, patterns, and descriptions. The description adds no additional semantics beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description explicitly states the action ('Remove'), the target resource ('persistent or file storage mount'), and the subject ('Coolify application'). It distinguishes clearly from sibling tools like 'coolify_delete_database_storage' by specifying 'application storage'.

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 specify when to use this tool versus alternatives (e.g., updating storage, or deleting database/service storage). However, the tool name and context provide implied guidance since it is the only delete for application storage among siblings. No when-not-to-use or prerequisites 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?

The description labels the tool as '[DESTRUCTIVE]' and states it deletes both schedule and archives, which provides adequate transparency about its irreversible effects. However, no annotations are provided to offer further context (e.g., destructiveHint, idempotency), so the description carries the full burden. It doesn't disclose whether the operation requires confirmation (the 'confirm' parameter is documented in the schema but not mentioned in the description), nor what happens if schedules/archives don't exist.

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 at 12 words, fitting the pattern of a clear one-liner. It includes a '[DESTRUCTIVE]' marker upfront that signals danger, which is helpful. Every word adds value—'backup schedule and archives' provides specificity. The description is efficient without being under-specified.

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

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

Given there is no output schema and the tool is destructive with 3 parameters, the description is minimally adequate. It identifies what is deleted but does not explain return behavior (e.g., success/error message), whether it is idempotent, or how to confirm the operation (the 'confirm' parameter). It covers the core intent but leaves gaps about the execution flow and edge cases.

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

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

Schema description coverage is 100%: all three parameters (uuid, storage_uuid, confirm) have descriptions in the schema. The description adds no additional parameter meaning beyond the schema, which is acceptable since the schema is rich and clear. However, the description does not hint that 'confirm' must be true for the operation to proceed, which could be useful context. With full schema coverage, 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?

The description states 'Delete the backup schedule and archives for an application storage', which clearly specifies the verb (delete), resource (backup schedule and archives), and scope (application storage). This differentiates it from siblings like 'coolify_delete_application_storage' (which deletes the storage itself) and backup tools for other resource types (database, service). However, it does not explicitly articulate the nuance of deleting both the schedule and existing archives.

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

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

The description implies usage context (when you want to remove backups for an application storage) but provides no guidance on when not to use this tool versus alternatives. There is no mention of prerequisites (e.g., needing to identify the storage_uuid first via coolify_list_application_storages) nor warnings about irreversible data loss. A sibling like 'coolify_set_application_storage_backup' suggests a counterpart for setting up backups, but the description does not connect these concepts.

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 includes the tag '[DESTRUCTIVE]' but provides no additional context about the destructive nature, such as irreversibility, impact on dependent records, or permission requirements. With no annotations provided, the description carries the full burden but fails to disclose more than what the tag implies. The presence of a 'confirm' parameter hints at a confirmation step, but the description doesn't explain its necessity.

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 front-loads the important information (destructive tag, verb, resource). No filler or redundancy. It earns a 4 because it is efficient, though it could be slightly more structured to include usage guidance.

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 tool with no annotations, output schema, or nested objects, the description is under-specified. It doesn't explain the confirmation parameter's role, the irreversible nature, or how to correctly obtain the necessary UUIDs. With 4 parameters and one being a required confirmation, this needs more context to guide correct invocation.

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

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

The input schema already describes all parameters with high coverage (100%), so the description doesn't need to add much. However, the schema descriptions are minimal (e.g., 'UUID of the database') and the description adds nothing about the relationships between parameters (e.g., that execution_uuid belongs to backup_uuid). The baseline of 3 is appropriate since schema coverage is high and the description provides no extra parameter 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?

The description states 'Delete a specific backup execution record' which clearly identifies the action (delete) and the resource (backup execution record). While it doesn't explicitly distinguish from sibling tools like coolify_delete_database_backup, the naming and description are clear enough. A score of 4 is appropriate as it lacks explicit differentiation from potentially similar deletion tools.

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

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

The description provides no guidance on when to use this tool versus alternatives, or any prerequisites or context. It only states the action without mention of required identification details or confirmation step. There is no mention of avoiding use or alternative tools, leaving the agent without clear usage direction.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It notes the action is destructive and permanent, but fails to explain critical requirements such as the mandatory 'confirm' parameter, the impact on volumes, or any irreversible side effects. Important behavioral traits are omitted.

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

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

The description is a single, front-loaded sentence with no filler. '[DESTRUCTIVE]' immediately signals severity, and the action is succinctly stated.

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

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

Given that this is a destructive operation with multiple boolean parameters (confirm, delete_volumes, docker_cleanup) and no output schema, the description is unduly brief. It does not explain the deletion process, safety checks, or what happens to associated resources, 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 100%, so the input schema already documents all four parameters with descriptions. The description adds no additional semantic information about parameters beyond the schema, meeting the baseline expectation.

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 'Permanently delete a Coolify database', specifying the action (delete) and resource (database), and explicitly marks it as destructive. This distinguishes it from sibling tools like coolify_stop_database (temporary) and coolify_create_database (creation).

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

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

The description provides no guidance on when to use this tool versus alternatives such as stopping or restarting the database, nor does it mention prerequisites like the need for a uuid or confirmation. It simply states the action without context.

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

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

With no annotations provided, the description carries the full burden. It only labels the operation as '[DESTRUCTIVE]' and states it deletes a configuration. It does not disclose that the 'confirm' parameter must be set to true, that the default behavior does not delete S3 files unless 'delete_s3' is true, or any consequences of deletion. The transparency is insufficient for a destructive 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 with a '[DESTRUCTIVE]' prefix, which is concise. However, it is under-specified and lacks any structure or additional context. It could be improved 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?

Given the tool has 4 parameters, is destructive, and has no output schema, the description is incomplete. It does not mention prerequisites (e.g., listing backups first), the requirement to set 'confirm' to true, or what the return value indicates. The description fails to cover key contextual 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 100%, so the baseline is 3. The description adds no additional meaning beyond the parameter names and types already documented in the schema. It does not explain the role of 'confirm' or 'delete_s3' in the context of deletion.

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 'Delete' and the resource 'scheduled backup configuration for a Coolify database'. It distinguishes from sibling tools like 'coolify_delete_backup_execution' (which deletes executions) and 'coolify_delete_database' (which deletes the database itself). 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?

There is no explicit guidance on when to use this tool versus alternatives. It does not mention that this tool deletes the configuration (not the execution) or that it requires a confirmation parameter. No exclusions or context are 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 are provided, so the description carries the full burden. It includes a '[DESTRUCTIVE]' tag, which hints at the operation's nature, but it does not disclose whether the operation is irreversible, what happens to the database, or that confirmation is required. The confirm parameter is present in the schema but not mentioned in the description.

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 at one sentence, which is good for front-loading. However, it lacks structure and does not use the available space to add useful information. It is not overly verbose, but it is too sparse to be considered well-structured.

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

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

Given the tool has 3 parameters, no output schema, and many sibling tools, the description is incomplete. It does not explain the return value, how to interpret the confirmation parameter, or how this tool differs from similar ones like coolify_delete_env. The context signals suggest a need for more detail, but the description provides only a single line.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no additional meaning beyond what the schema already provides. For example, it does not explain the purpose of each parameter or provide context for their values.

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

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

The description clearly states the action: 'Delete an environment variable from a Coolify database'. It uses a specific verb and resource, and the mention of 'from a Coolify database' distinguishes it from sibling tools like coolify_delete_env (which might delete from other contexts). However, it does not elaborate on the exact inputs or scope, which could be more precise.

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 vs alternatives. For example, there is no mention of prerequisites (e.g., needing the database UUID and env UUID), when to prefer this over coolify_update_database_envs_bulk, or when not to use it. The description is purely declarative.

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 explicitly marks the tool as '[DESTRUCTIVE]', which is helpful for behavioral transparency. With no annotations provided, this is a positive disclosure. However, it does not explain what happens after deletion (e.g., whether it's permanent, if confirmation is required, or if it affects running databases). The presence of a 'confirm' parameter is implied by the behavior but not explicitly stated in the description.

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

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

The description is a single, concise sentence that takes about 15 words to convey the core purpose. The '[DESTRUCTIVE]' tag at the start provides immediate warning. It is front-loaded and to the point. While it could include a bit more guidance, it does not waste 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?

Given that there is no output schema, the description should compensate by explaining what the tool returns upon success or failure (e.g., confirmation message, error if storage not found). It also lacks any mention of error states, idempotency (e.g., deleting already-deleted storage), or dependencies (e.g., backup relationships). For a destructive tool with no annotations or output schema, this is inadequate.

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 three parameters adequately. The description adds no additional meaning beyond the schema's parameter descriptions. The tool name and description implicitly clarify that 'uuid' is the database's UUID and 'storage_uuid' is the storage to delete, but 'confirm' is only documented in the schema. With full schema coverage, a 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?

The description clearly states the verb ('Remove'), resource ('persistent or file storage mount'), and target ('from a Coolify database'). It distinguishes itself from sibling tools like `coolify_delete_application_storage`, `coolify_delete_service_storage`, and `coolify_delete_database_storage_backup` by specifying it targets database storage mounts. However, it could be more precise by noting it deletes a specific storage UUID rather than all storage for a database.

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. Among siblings, `coolify_list_database_storages` lists available storages, `coolify_create_database_storage` creates them, and `coolify_update_database_storage` modifies them, but no mention is made of prerequisites (e.g., listing storages first to get the storage_uuid) or when not to use it (e.g., if storage is in use by backups). The description assumes the agent already knows the context.

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

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

With no annotations provided, the description carries the full burden of disclosing behavioral traits. While it marks the tool as [DESTRUCTIVE] and mentions it deletes 'the backup schedule and archives', it doesn't disclose whether this action is irreversible, what happens to in-progress backups, whether it requires specific permissions, or what the response looks like. The 'confirm' parameter in the schema hints that confirmation is needed, but the description doesn't explain that it must be set to true to proceed. The contradiction flag is false because there are no annotations to contradict.

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

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

The description is a single, concise sentence that immediately marks the tool as destructive with a bracket prefix. It front-loads the key warning. The sentence could be slightly improved by placing the [DESTRUCTIVE] label at the very beginning before 'Delete' for even clearer emphasis, and by adding a brief note about confirmation, but overall it's 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?

Given that parameters are fully covered in the schema, no output schema exists, and the tool is destructive, the description provides adequate but not comprehensive detail. It names the two deleted components (schedule and archives) and warns of destruction, but lacks behavioral context (irreversibility, prerequisites) and usage guidelines. For a destructive operation, more guidance is warranted.

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%, so the schema already describes all three parameters ('uuid', 'confirm', 'storage_uuid'). The description adds no additional semantic information beyond what's in the schema – it doesn't explain how the uuid and storage_uuid relate (e.g., that uuid is the database's UUID and storage_uuid is the storage's UUID, and both are needed to identify a specific backup schedule). It also doesn't clarify that 'confirm' must be true for the operation to succeed. Baseline 3 is appropriate given full 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?

The description clearly states the verb 'Delete' and the specific resource: 'backup schedule and archives for a database storage'. This distinguishes it from siblings like 'coolify_delete_database_backup' (which likely deletes only a backup execution result) and 'coolify_delete_application_storage_backup'. However, it could be more precise by explicitly noting that this refers to the entire backup schedule, not just a single backup.

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 some context by labeling it [DESTRUCTIVE], implying it should be used with caution, but it provides no explicit when-to-use or when-not-to-use guidance. There's no mention of alternatives or prerequisites (e.g., that the database and storage must exist). The sibling tools list suggests there are other backup-related tools (like 'coolify_set_database_storage_backup', 'coolify_run_database_storage_backup', 'coolify_delete_database_backup'), but the description doesn't help the agent choose among them.

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

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

Annotations are not provided, so the description bears full burden. It marks the operation as '[DESTRUCTIVE]' but does not explain consequences (e.g., the env var is permanently removed, no undo, impact on running application). It also does not confirm whether the confirm parameter is required or what happens if omitted. No side effects 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, effective sentence. It front-loads the destructive nature with '[DESTRUCTIVE]', saving the agent from misinterpreting the tool as non-destructive. No wasted 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?

The tool is simple (3 params, no nested objects, no output schema). The description is mostly adequate given the simplicity, but it lacks confirmation about the return value (e.g., success message or error format) and does not state that env_uuid must come from a list call. For a destructive operation, more completeness would be valuable.

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%, so the schema documents all parameters with descriptions. The description adds the label '[DESTRUCTIVE]' which aligns with the confirm parameter's intent, but adds no further semantics beyond the schema. Baseline 3 is appropriate.

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

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

The description clearly states the action: 'Delete an environment variable from a Coolify application'. The verb 'Delete' and resource 'environment variable' are specific. It distinguishes from sibling tools like coolify_create_env, coolify_update_envs_bulk, and coolify_delete_application_storage by naming the exact resource type. However, it does not differentiate from coolify_delete_database_env or coolify_delete_service_env, which are similar delete-env tools for other contexts.

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 like coolify_list_envs (to find env_uuid) or coolify_delete_database_env. It only implies usage for deleting env vars from applications. No prerequisites or when-not-to-use are stated.

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 explicitly marks the tool as [DESTRUCTIVE] and requires environment emptiness, but does not disclose other behaviors like whether the operation is irreversible, if it affects dependent resources, or any permission/authorization 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?

The description is a single sentence that is direct and front-loaded with key information: it states the destructive nature, the resource type, the target, and the precondition. No wasted 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?

Given the tool is destructive and has 3 parameters (including a confirm flag), the description should explain when to set confirm, potential return values, or error states (e.g., what happens if the environment is not empty). Without an output schema, the description must compensate but does not. It is underspecified for safe usage.

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 baseline is 3. The description adds no additional meaning beyond the schema; for example, it does not explain the difference between environment_name and environment_uuid, nor that 'confirm' is required for destruction. The description adds no parameter-specific 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?

The description states it deletes an environment from a Coolify project, with a clear precondition ('must be empty'). The name 'coolify_delete_environment' is descriptive and distinct from siblings like 'coolify_delete_project' and 'coolify_delete_application'.

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 a precondition ('environment must be empty') but does not guide when to use this tool vs. alternatives like updating an environment or listing environments first to verify emptiness. No when-not-to-use guidance.

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

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

With no annotations provided, the description carries the full burden. It marks the operation as '[DESTRUCTIVE]' but does not disclose what happens to the integration, any side effects, or the need for the 'confirm' parameter. Important behavioral details are missing.

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

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

The description is a single, focused sentence with the '[DESTRUCTIVE]' prefix front-loaded. It is concise without unnecessary words, though it could be slightly more structured.

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

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

The description is minimal for a destructive operation. It does not explain the 'confirm' parameter's role, how to obtain the 'id' (e.g., from coolify_list_github_apps), or what the outcome looks like. Given the simplicity of the tool, more context would improve completeness.

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% with both 'id' and 'confirm' documented. The description adds no additional meaning beyond the schema, so baseline 3 is appropriate.

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

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

The description explicitly states the verb 'Delete' and the resource 'GitHub App integration', clearly distinguishing it from sibling tools like coolify_list_github_apps and other delete tools.

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

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

The description implies the tool is for deleting GitHub App integrations but provides no explicit guidance on when to use it versus alternatives or what prerequisites are needed. The usage is implied by the 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?

The description notes the destructive nature with '[DESTRUCTIVE]' and the condition 'Blocked if in use'. These are valuable behavioral hints. However, it fails to mention the confirm parameter, which is critical for executing the destructive operation. Without annotations, the description carries full burden and misses this key safety behavior.

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

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

The description is very concise, using one sentence plus a tag. It is front-loaded with the destructive marker. However, it omits necessary context about the confirm parameter, which would only add minimal length. Slightly under-specified for safe operation.

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 delete tool with 2 parameters and no output schema, the description should cover the confirm requirement and what the user expects after deletion. It mentions the block-if-in-use constraint but ignores the confirm parameter, which is critical for operation. This leaves the agent potentially unaware of required confirmation, making the tool hazardous to use incorrectly.

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 baseline is 3. The description adds no additional parameter information beyond what the schema already provides (uuid and confirm explanations). It does not compensate for or enrich the semantic understanding of the parameters.

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

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

The description explicitly states 'Delete an SSH private key', providing a specific verb and resource. The tool name includes 'delete_private_key', so there is no ambiguity. It distinguishes itself from sibling tools like coolify_create_private_key or coolify_list_private_keys through clear naming and action.

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 no guidance on when to use this tool versus alternatives (e.g., list keys first or use update). It does not mention prerequisites or scenarios where deletion is appropriate. The only contextual hint is 'Blocked if in use', but that is a constraint rather than usage direction.

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

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

No annotations are provided, so the description must carry the full burden. It explicitly calls out that the operation is destructive, permanent, and deletes all environments. The description also aligns with the confirm parameter, which is a common safety pattern. This is strong behavioral transparency for a deletion tool, though it could mention that other resources within the project are also removed.

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, focused sentence with a valuable [DESTRUCTIVE] prefix. It is concise and front-loaded, though the tag could potentially be formatted more clearly (e.g., bold or italic) for readability. No extraneous 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?

There is no output schema, and the description doesn't mention return values or error cases. However, for a deletion tool, the side effect (deletion) is the primary behavior, and the description covers that well. A brief note about what happens on success (e.g., 'Returns success message') would improve completeness.

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 both parameters have descriptions: uuid as 'UUID of the resource' and confirm as 'Set to true to confirm this destructive operation'. The description does not add extra meaning beyond what the schema already provides. A baseline 3 is appropriate here.

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 'delete', the resource 'Coolify project', and the scope 'all its environments'. It also uses the [DESTRUCTIVE] tag to signal severity. This effectively distinguishes it from sibling tools like coolify_create_project or coolify_get_project.

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 includes a '[DESTRUCTIVE]' prefix that implies caution, and the tool has a confirm parameter for safety. However, there is no explicit guidance on when to use this versus other delete tools (e.g., coolify_delete_environment) or any prerequisites like needing the project's UUID. Usage context is implied but not fully detailed.

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 burden and does usefully flag irreversibility ("[DESTRUCTIVE]", "Permanently") and the cascading stop of hosted resources. However it says nothing about the confirm flag requirement, the force bypass, or that delete_from_provider invokes external cloud APIs, all of which matter for a destructive call.

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

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

A single compact sentence with the destructive warning front-loaded in brackets. Nothing is redundant or buried.

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, unannotated tool the description covers permanence and the resource cascade, and the schema covers parameters thoroughly. Still missing is any mention of confirmation requirements or the external-provider side effect, which an agent needs before invoking.

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 uuid, force, confirm, and delete_from_provider are already well documented in the schema. The description adds no parameter-level detail beyond what the structured fields provide, so 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 ("Permanently delete a server") plus the cascade consequence ("stop all its resources"). It is clearly distinguishable from siblings like coolify_delete_application or coolify_delete_database by the server resource, though it does not explicitly name an 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 guidance on when to use this versus coolify_update_server, coolify_delete_application, or other delete variants, and no stated prerequisites such as needing the server stopped or a provider token. The agent must infer when deletion is appropriate.

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 burden, and it does disclose irreversibility ('Permanently'). However, it omits key behavioral details the agent needs: that a confirm flag gates execution, and that by default associated volumes and Docker resources are also destroyed unless the boolean params are changed.

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

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

A single short sentence with the critical warning front-loaded in brackets; nothing is wasted. It is arguably too terse given the tool's destructive, five-parameter nature, but it is not 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?

For a destructive, multi-parameter mutation tool with no annotations and no output schema, the description should at least flag the confirm requirement and the default destruction of volumes/Docker resources. It leaves the agent to discover those from the schema alone, which is a meaningful gap for an irreversible 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?

Schema description coverage is 100%, so every parameter including confirm, delete_volumes, docker_cleanup, and delete_from_coolify_only is documented in the schema itself. The description adds no additional parameter semantics, so 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 ('delete a Coolify service'), and the DESTRUCTIVE tag plus 'Permanently' makes the intent unambiguous. It distinguishes itself from siblings like coolify_delete_application and coolify_delete_database by naming the resource type, though it doesn't explicitly contrast with coolify_delete_service_storage.

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 choose this over alternatives such as coolify_delete_application or coolify_delete_service_storage, and no mention that the 'confirm' flag must be set to true for the operation to proceed. The only implicit cue is the destructive warning, which is not the same as usage guidance.

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

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

With no annotations, the description carries full burden for behavioral disclosure. It includes the label '[DESTRUCTIVE]' and the schema has a 'confirm' parameter, both hinting at destructiveness. However, it does not explain side effects (e.g., whether deletion triggers a redeploy), permanence, or auth requirements. The label provides some transparency but lacks completeness.

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

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

The description is a single sentence with a clear action and a useful '[DESTRUCTIVE]' prefix. There is no redundant information, and every word contributes to understanding. It is ideally concise.

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

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

For a destructive operation with no output schema and no annotations, the description is too sparse. It does not explain what happens after deletion, how to confirm, what the response looks like, or how the two required UUIDs relate to each other. The presence of the 'confirm' parameter is a key usage detail that the description omits.

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% (all parameters have descriptions), so baseline is 3. The tool description adds no extra meaning beyond what the schema already provides (e.g., it does not explain how to obtain the UUIDs or the role of 'confirm'). The schema is self-sufficient, so the description does not degrade but also does not enhance.

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

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

The description states a specific verb ('Delete') and resource ('environment variable from a Coolify service'), making the core purpose clear. However, it does not differentiate this tool from sibling tools like 'coolify_delete_env' or 'coolify_delete_database_env', which have overlapping functionality.

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 (e.g., coolify_delete_env for applications, coolify_delete_database_env for databases). Prerequisites (e.g., having the service UUID and env_uuid) are not mentioned, and no when-not-to-use conditions are given.

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

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

The description labels the tool as '[DESTRUCTIVE]', explicitly warning about its irreversible nature. This is helpful beyond the input schema, which includes a 'confirm' parameter for destructive operations. However, with no annotations provided, the description could further detail that deletion is permanent and not recoverable, or note that it only removes the schedule, not the service itself.

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 that is clear and to the point, front-loading the destructive nature. It is short but not overly terse. Could be slightly improved by adding a note about the 'confirm' parameter requirement, but it remains 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?

Given the tool has 3 parameters (all documented in schema) and no output schema, the description conveys the core operation. However, it lacks context about the relationship to sibling tools (e.g., scheduling/lifecycle) and does not mention that the 'confirm' boolean is likely required for execution. A mention of the task lifecycle (e.g., 'This cannot be undone') would improve completeness.

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 schema already provides descriptions for all 3 parameters (uuid, confirm, task_uuid) with constraints (patterns, lengths), achieving 100% coverage. The description does not add any additional parameter-level guidance beyond what the schema offers. A 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?

The description explicitly says 'Delete a scheduled task from a Coolify service', which specifies the verb 'delete', the resource 'scheduled task', and the scope 'from a Coolify service'. It is clearly distinguished from sibling tools like 'coolify_delete_application_scheduled_task' and 'coolify_list_service_scheduled_tasks'.

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 (e.g., service vs. application scheduled tasks). It does not mention prerequisites (e.g., needing UUIDs), or when not to use it. A destructive operation like this would benefit from explicit caution or alternative tools for listing tasks first.

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 adds the '[DESTRUCTIVE]' prefix to signal that this is a destructive operation, which is helpful. The description does not clarify whether removing storage deletes data permanently or what permissions are needed, but given the tool name and the common semantics of deleting storage mounts, a 3 is fair.

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

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

The description is a single, clear sentence with a critical warning prefix. It contains no filler, is front-loaded with the destructive indicator, and every word earns its place.

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

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

For a destructive tool with 3 simple parameters, no output schema, and no nested objects, the description is adequate. It communicates the core action, the resource type, and the destructive nature. It could optionally clarify that removal is permanent (but that is implied by 'delete'). Given the complexity level, it is sufficiently complete.

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

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

Schema description coverage is 100% with well-defined parameters (uuid, confirm, storage_uuid). The description's mention of 'storage mount' and 'Coolify service' adds context by implying that 'uuid' refers to a service UUID and 'storage_uuid' to a storage mount, which is already in the schema but reinforced. The description adds value by linking the action to the parameter usage.

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), the resource (persistent or file storage mount), and the target (Coolify service). The sibling tools include coolify_delete_application_storage and coolify_delete_database_storage, so this tool's scope is precisely differentiated by the 'service' context in the description.

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

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

The description explicitly marks this as [DESTRUCTIVE] in the text, which provides a strong usage signal. The sibling tools include create and update variants for service storage, offering implied alternatives. However, there is no explicit statement about when to use this tool vs coolify_delete_application_storage (e.g., for a service vs application context), missing a minor clarity opportunity.

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 labels the tool as '[DESTRUCTIVE]', which is appropriate for a delete operation. Since no annotations are provided, the description must disclose behavioral traits, and it does flag the destructive nature. However, it does not specify what exactly gets destroyed (e.g., backup schedule, archives, or both), nor does it mention whether the operation is reversible or requires authorization beyond the confirm parameter. The description 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 short sentence that quickly communicates purpose and a key behavioral trait (destructive). It is front-loaded with the '[DESTRUCTIVE]' label. One minor improvement could be moving the label to the end or adding a brief second sentence for when to use, but it remains efficient and to the point.

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

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

Given the tool has 3 parameters, 100% schema coverage, and no output schema, the description is somewhat complete but lacks guidance on what happens after deletion (e.g., no response structure) and does not explain the relationship between `uuid` and `storage_uuid`. The sibling tools offer many storage/backup operations, so the description could better clarify the exact scope of deletion, but it is sufficient for basic 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?

Schema description coverage is 100%, so the baseline is 3. The description adds value by clarifying that the operation is 'destructive' and that the `confirm` parameter is required to proceed, which is not fully conveyed by the parameter description alone ('Set to true to confirm this destructive operation'). This extra context raises the score to 4.

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

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

The description clearly states the action—'Delete the backup schedule and archives'—which establishes the verb (delete) and the resource (service storage backup). It distinguishes this tool from siblings like `coolify_delete_service_storage` (which deletes only the storage, not its backups). However, it does not explicitly mention that it is a sibling-related differentiation, so it falls short of 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?

The description provides a general context for when to use the tool: to delete a backup schedule and its archives. It does not explicitly state when not to use it or contrast with alternatives like `coolify_set_service_storage_backup` or `coolify_run_service_storage_backup`. The tool is destructive, requiring a confirm parameter, but no guidance on prerequisites (e.g., storage must exist) is given.

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

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

With no annotations, the description carries the burden and does well: the [WRITE] marker signals mutation, the version floor and required deploy token scope are spelled out, and the git-vs-docker branch clarifies which parameter set applies. It stops short of saying what happens when the preview does not yet exist versus already exists, or what the call returns.

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 [WRITE] marker front-loaded and the app-type branching in a compact parenthetical. Every clause carries information, though the parentheticals make it slightly dense to parse in one pass.

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 mutation with no annotations and no output schema, the description covers the essential context: that it deploys, the auth scope, the version requirement, and the app-type parameter split. Remaining gaps (creation-vs-redeploy semantics, response shape) are minor given the rich schema descriptions.

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 uuid, force, commit, git_type, docker_tag, instant_deploy, and the PR fields. The description's mention of git_type/commit for Git apps and docker_tag for Docker Image apps adds a useful at-a-glance summary but largely restates schema text, so 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 (open or redeploy) and resource (preview of a pull request) with the parent application scope implied by the required uuid. The [WRITE] tag and the explicit 'preview' qualifier cleanly separate it from siblings like coolify_trigger_deploy and coolify_update_application_preview.

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 clear triggering conditions (opening or redeploying a PR preview) plus prerequisites: Coolify v4.4+ and a token with deploy permission. It does not name alternatives such as coolify_update_application_preview or coolify_get_application_preview, so an agent must infer when not to use it, which keeps it below a 5.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. The description only states it 'Get detailed information', which implies a safe, read-only operation. However, it does not disclose whether the operation requires specific permissions, what 'detailed information' encompasses (e.g., configuration, status, logs), whether it triggers side effects, or if there are rate limits. For a read tool without annotations, this is a significant 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 a single, clear sentence of 10 words with no wasted language. It is efficient and front-loaded. However, it could be slightly improved by adding a line about UUID source or return value 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?

Given the tool has 1 parameter, no output schema, and no annotations, the description provides minimal but sufficient context for a simple retrieval operation. It states the resource type and action. However, for an agent to invoke it correctly, more context would be helpful, such as how to obtain the UUID (e.g., from list results) or the kind of data returned (e.g., 'Returns configuration, status, and deployment details'). It is 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?

The input schema has 1 parameter with 100% description coverage ('UUID of the resource'). The description does not add any meaning beyond the schema; it does not clarify what type of UUID (application-specific), nor does it define constraints like format or where to find it. Baseline 3 is appropriate as the schema already fully documents the parameter.

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 'Get detailed information about a specific Coolify application', using a specific verb ('Get'), a specific resource ('Coolify application'), and the qualifier 'detailed information' to indicate scope. It effectively distinguishes this tool from siblings like 'coolify_get_database' and list tools like 'coolify_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 description implies this tool is used to retrieve details for a single application. However, it provides no explicit guidance on when to use it versus alternatives (e.g., 'coolify_list_applications' for overview, or what 'detailed information' includes), nor does it state prerequisites or exclusions. The context is clear but shallow.

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 behavioral disclosure burden. 'Get' clearly implies a read operation and the version note adds useful compatibility context, but it does not describe permissions, failure behavior, or response characteristics.

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 tightly scoped sentence with no wasted wording. The core operation is front-loaded, and the version constraint is appended efficiently.

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 two-parameter read tool with fully documented schema fields, the description is largely complete and tells the agent what resource is returned. Because there is no output schema, it could say more about the returned preview object, but that is a minor gap for this low-complexity tool.

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

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

Schema description coverage is 100%, so both parameters are already documented as the parent application UUID and pull request number. The description aligns with that but adds no additional parameter semantics beyond what the schema provides.

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

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

The description states a specific verb and resource: 'Get one preview deployment of an application by pull request number.' It also distinguishes the retrieval of a single preview from listing previews, and notes the Coolify version requirement.

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 'one preview ... by pull request number,' suggesting this is for retrieving a single known preview. However, it does not explicitly say when to use this instead of coolify_list_application_previews, coolify_get_application_preview_logs, or other sibling tools.

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