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

Annotations already indicate readOnlyHint=false (mutation), but the description adds valuable behavioral details: it explicitly says the operation is for queued/in-progress deployments and that terminal states yield UNSUPPORTED_OPERATION. The audit trail reference ('coolify.deployment.cancel') provides additional transparency about logging, exceeding what annotations convey.

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

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

The description is two short sentences: the first delivers the core action and scope, the second adds a critical edge case and audit context. No wasted words, and the key information is front-loaded.

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

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

For a single-parameter, low-complexity cancel operation, the description covers the purpose, applicable state, error behavior for terminal states, and audit logging. It does not elaborate on return formats or asynchronous behavior, but given the lack of an output schema and the simplicity of the operation, the context 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 coverage is 100%, with a single parameter 'deployment_uuid' fully described as 'Deployment UUID to cancel'. The description does not add additional parameter semantics beyond what the schema already provides, so the baseline of 3 is appropriate.

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

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

The description uses a specific verb ('Cancel') and resource ('queued or in-progress deployment'), clearly distinguishing it from deployment listing, getting, or deploying tools. It also states the exact scope (non-terminal states) and notes the unsupported case for terminal states, making the purpose 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 when to use the tool: when a deployment is queued or in-progress, not terminal. It also states that terminal states will return UNSUPPORTED_OPERATION, effectively informing users when not to attempt cancellation. However, it does not explicitly name alternative tools or provide broader context on when cancellation is appropriate versus other actions.

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

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

The annotations already convey mutation (readOnlyHint=false) and non-idempotency. The description adds a policy caveat ('Subject to operation mode, allowlist, and production guard policies'), which is useful, but it is vague and does not explain exact failure conditions, side effects, or return 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 two sentences, front-loaded with the core purpose, and followed by a concise policy caveat. Every word earns its place with no redundancy.

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

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

For a 10-parameter create operation with no output schema, the description is minimal. It does not explain relationships like source_type to repository_url/build_pack, and the policy caveat is vague. The rich schema helps, but the description alone leaves key operational details implicit.

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 10 parameters include descriptions, so the description does not need to compensate. The text adds no parameter-specific detail beyond what the schema already 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 uses a specific verb ('Create') and identifies the resource ('a new application') plus the scoping context ('in a project environment'). This clearly distinguishes it from sibling tools like coolify_create_service and coolify_create_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?

It clearly states the intended use: creating an application within a project environment. However, it does not explicitly name alternatives or state when not to use this tool (e.g., for services or databases), though the resource type makes that 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?

Annotations are all false, so the description carries the transparency burden. It adds behavioral context not in annotations: 'Cron expression is validated' and 'Audit: coolify.database_backup_config.create' disclose validation and audit behavior. No contradictions 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?

Two concise sentences deliver purpose, a key behavioral note, and audit information without waste. The description is front-loaded with the primary action and every sentence adds value.

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

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

Despite having 5 parameters and no output schema, the description covers the essential purpose and one key constraint (validation). The schema handles parameter details. It could mention return value or on-success behavior, but for a straightforward create operation this is sufficient.

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 parameters are already fully documented. The description's mention of cron validation adds minimal value beyond the schema's 'Cron expression for backup schedule'. 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 specific verb 'Create' and resource 'backup configuration for a database', clearly distinguishing it from sibling tools like coolify_update_backup_config and coolify_list_database_backups. It unambiguously states what the tool does.

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 use when creating a new backup configuration for a database, but does not explicitly mention alternatives or exclusions. It provides clear context without naming when to use this tool over update_backup_config or list_database_backups, so it falls short of 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?

Annotations already indicate readOnlyHint=false, destructiveHint=false etc., so the description does not need to restate these. It adds valuable behavioral context by warning that 'Passwords and connection strings are NEVER returned in response,' which is a critical behavioral trait not inferable from annotations. It also mentions the safe-write mode requirement, adding further transparency about operational conditions.

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

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

The description is two sentences, front-loaded with the primary purpose, and every sentence adds value: the first defines the function, the second provides critical safety/behavioral warnings. It is concise without unnecessary detail.

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

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

The description covers the essential context for a create database tool: what it does, the safe-write mode requirement, and the crucial fact that secrets are not returned. Although there is no output schema and the response format is not described, the warning about passwords and connection strings partially compensates by setting expectations. The parameter descriptions in the schema fill in the remaining 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?

The input schema has 100% description coverage, with each parameter already documented (e.g., name, version, server_uuid). The tool description does not add any additional parameter semantics beyond what the schema provides. Since the schema carries the full burden, a 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 clearly states the tool's function: 'Create a new database in a project environment.' The verb 'Create' and resource 'database' are specific, and the context ('project environment') distinguishes it from sibling tools like create_application or create_service. No ambiguity about its purpose.

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

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

The description provides clear usage context by stating it creates a database in a project environment and notes a prerequisite: 'Requires safe-write operation mode.' While it does not explicitly name alternatives or exclusions, the context is clear enough for an agent to select this tool when creating a database. The safe-write requirement is important operational 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?

Beyond the annotations (readOnly=false, destructive=false), the description adds that the operation is subject to policies and creates an audit entry ('Audit: coolify.destination.create'). This gives useful behavioral context without contradicting annotations.

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

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

Two concise sentences: the first states the purpose, the second covers policies and audit. No wasted words, and the most important information is front-loaded.

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

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

Given the schema covers all parameters, annotations define safety, and the description adds policy/audit context, the description is sufficient for an agent to understand the tool's role and constraints. A small gap is lack of mention about return values, but there is no output schema expected.

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 100% coverage with descriptions for every parameter. The tool description does not add additional parameter-level guidance, so the baseline of 3 applies.

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

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

The description clearly states the verb and resource: 'Create a Docker network destination on a server.' This distinguishes it from sibling create tools (application, service, database, storage) and accurately describes the core function.

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 mentions that usage is 'subject to operation mode, allowlist, and production guard policies,' which provides context about constraints but does not explicitly state when to use this tool versus alternatives or when not to use it. No alternative tools are named.

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

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

Annotations already indicate a write operation (readOnlyHint false, destructiveHint false). The description adds a specific operational requirement: safe-write mode. However, it doesn't elaborate on failure modes or idempotency, which would be useful.

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

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

Two short sentences, each carrying distinct information: the operation and the operational prerequisite. No redundancy.

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

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

The tool is simple with two well-documented params and annotation coverage. The description covers the core purpose and a key requirement. It does not mention return values, but for a create operation it's adequate.

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

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

Both parameters are fully described in the schema (100% coverage), so the description adds no additional parameter meaning. 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 clearly states the action ('Create a new environment') and the target resource ('within a project'). It distinguishes by resource type, though it doesn't explicitly reference alternatives.

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 for creating an environment in a project but provides no explicit when-to-use vs alternatives. It mentions a prerequisite (safe-write mode), but not selection guidance.

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

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

Annotations already indicate readOnly=false, so the description's 'Requires safe-write operation mode' adds a small operational requirement not covered by annotations. However, it does not disclose return behavior, uniqueness constraints, or side effects beyond the mode requirement.

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 concise sentence with no filler. Every word contributes meaning, balancing brevity with a clear statement of purpose and a safety requirement.

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

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

With no output schema and minimal annotations, the description fails to explain what the create operation returns, any prerequisites, or how projects relate to other resources. This is inadequate for an agent to fully complete the invocation lifecycle.

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 clear descriptions for 'name' and 'description'. The tool description adds no additional parameter-level detail, so it meets the baseline without enhancing understanding.

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

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

The description clearly states the tool's function: 'Create a new project.' It uses a specific verb and resource, differentiating it from sibling tools like create_application or create_database based on the project resource.

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

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

No guidance is provided on when to use this tool versus alternatives such as create_application or create_service. The only added note about 'safe-write operation mode' is a constraint, not usage context or exclusion criteria.

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

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

Beyond the annotations (all false, indicating no read-only, idempotent, or destructive hints), the description adds important behavioral context: 'Credentials are never returned or logged,' subject to operation mode policy, and audit logging. These are meaningful security and policy disclosures that the annotations do not convey, though the operation mode policy itself is vague.

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

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

The description is three concise sentences, each providing distinct value: purpose, security behavior, and audit. No filler or redundancy, and the most essential information is front-loaded in the first sentence.

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 create tool with no output schema, the description covers key context: purpose, authentication scope, security guarantees, policy constraint, and audit. It does not mention return values or prerequisites beyond authentication, but the essential context for invoking the tool is present and well-integrated.

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 eight parameters. The description adds no parameter-specific detail beyond the schema, and any mention of credentials relates to security rather than parameter semantics. Baseline is 3 because the schema carries the burden.

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 'Create a new S3 storage configuration' with a clear verb and resource, and scopes it to 'the authenticated team.' This distinguishes it from generic storage creation tools in the sibling list, such as coolify_create_storage, and aligns with its S3-specific name.

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 clearly implies this tool is for creating S3 storage configurations, which is sufficient context. However, it does not explicitly name alternatives or state when not to use it, though the sibling list includes closely related tools like coolify_create_storage and coolify_validate_s3_storage. The context is clear, but exclusions are absent.

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

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

Annotations declare readOnly=false, idempotent=false, and destructive=false, but the description adds valuable behavioral context: 'Subject to operation mode, allowlist, and production guard policies' and 'Cron expression is validated.' This goes beyond the annotations by informing the agent about potential restrictions and validation 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 two sentences and 30 words, front-loaded with the action and object. It includes necessary constraints without fluff, and every sentence contributes to understanding the tool's purpose and limitations. No redundant repetition of schema 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 tool with 9 parameters and no output schema, the description conveys essential context: it targets applications/services, is subject to policies, and validates cron expressions. It does not explain return values or failure behavior, but the schema is richly described and the annotations provide safety profile, making the description reasonably 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 100% description coverage, meaning all parameters are documented in the schema itself. The description adds minimal parameter-specific meaning beyond mentioning that cron expressions are validated, which aligns with the 'schedule' parameter. Since schema covers the details, 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 tool's action: 'Create a scheduled task (cron job) on an application or service.' This specific verb+resource combination distinguishes it from siblings like update_scheduled_task, execute_scheduled_task, and list_scheduled_tasks, which cover other lifecycle operations.

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 by mentioning 'application or service' and constraints like 'operation mode, allowlist, and production guard policies,' but it does not explicitly state when to use this tool versus alternatives (e.g., update_scheduled_task for modifying existing tasks). No exclusions or alternative tool names 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?

The description adds the requirement of safe-write operation mode, which is behavioral context beyond the annotations. However, it does not disclose other potential side effects, permissions, or response behavior. Annotations already indicate a write operation, so the extra value is limited but present.

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

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

The description is two short sentences with no superfluous content. It front-loads the primary purpose and adds the key requirement, making it highly concise and 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?

For a creation tool, the description is minimally adequate but lacks details on return values, workflow after creation, or potential side effects. The schema and annotations cover parameter meanings and the write nature, but the description alone would leave some gaps for an agent handling complex scenarios.

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 parameters. The description adds no additional parameter-level meaning, matching the baseline of 3 for high 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 tool creates a new service in a project environment, using a specific verb ('create') and resource ('service'). It distinguishes from sibling tools like coolify_create_application and coolify_create_database by focusing on 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 useful context by noting that safe-write operation mode is required, which tells the agent when the tool can be invoked. It does not explicitly mention alternatives or exclusions, but the context is clear enough for an agent to infer appropriate use.

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 indicate readOnlyHint=false, destructiveHint=false, idempotentHint=false, and openWorldHint=false. The description adds meaningful behavioral context: 'Path traversal is validated' and 'Subject to operation mode, allowlist, and production guard policies,' plus an audit trail. These details go beyond the annotations and help the agent anticipate validation and policy checks. No contradiction with annotations found.

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 exceptionally concise: three short sentences plus an audit tag. It front-loads the primary purpose and then adds security/policy context without unnecessary fluff. Every sentence earns its place, making it easy to scan and parse.

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 creation tool with 6 parameters, no output schema, and limited annotations, the description provides the core purpose and some constraints but lacks operational context: no mention of expected response, required permissions, potential side effects, or when to choose this over S3 storage. The schema covers parameters, but the description does not fully compensate for the missing output schema and sibling differentiation.

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 fully documents all parameters. The description adds some contextual value by mentioning path traversal validation, which relates to source/destination parameters, but it does not elaborate on parameter-specific formats, defaults, or relationships beyond what the schema already provides. 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 specific action ('Create a storage mount') and target ('for a resource'), clearly distinguishing this from S3 storage creation (e.g., coolify_create_s3_storage). It also mentions path traversal validation, which adds specificity. However, it does not explicitly contrast with sibling storage tools, so it falls short of a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives like coolify_create_s3_storage. It mentions policy constraints ('operation mode, allowlist, and production guard policies') but these are restrictions, not usage directions. There is no explicit 'use this when...' or reference to alternative tools, leaving the agent to infer when this tool 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?

Annotations already communicate safety profile (readOnlyHint=false, destructiveHint=false, idempotentHint=true). The description adds context about operation mode, allowlist, and production guard policies, which is useful but does not explain deployment behavior (e.g., asynchronous process, return format).

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 states the action and key constraints. It is well-structured, front-loaded, and contains no unnecessary words.

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

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

The description is terse and, with no output schema, does not explain return values or post-deployment behavior. It includes policy constraints but lacks details on async behavior or error scenarios, leaving some gaps for an agent making full use of the tool.

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

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

Schema description coverage is 100%, so all parameters are already documented with descriptions. The tool description adds no additional parameter meaning beyond the schema, justifying the baseline score of 3.

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 ('Deploy a resource') with a specific verb and resource, differentiating it from create/update/cancel siblings. However, it does not explicitly contrast with related actions like 'start' or 'restart', so it lacks explicit sibling differentiation.

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

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

The description provides no guidance on when to use this tool versus alternatives like coolify_start, coolify_restart, or coolify_cancel_deployment. It only mentions policy constraints, which is a caveat 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?

Annotations already indicate the operation is not read-only and not idempotent. The description adds the caveat "Subject to operation mode, allowlist, and production guard policies," which is policy context not conveyed by annotations. However, it does not disclose what happens upon execution (e.g., triggers an async run, returns an execution ID) or any side effects. It adds a little value but misses key behavioral details.

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

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

The description is extremely concise—a single sentence that front-loads the action and includes a relevant policy caveat. Every word earns its place; there is no wasted text or redundancy with the schema.

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 an action with no output schema, the description is minimal but adequate for a basic trigger operation. It lacks information about return values, error conditions, or subsequent verification steps (e.g., checking task executions via get_task_executions). Since the schema and annotations cover safety and parameters, this is a clear gap but not a fatal 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?

The input schema provides descriptions for all three parameters (task_uuid, resource_type, resource_uuid) with full coverage (100%). The description adds no additional parameter semantics or relationships. Since the schema already documents each parameter, the baseline of 3 is appropriate; the description does not enhance understanding 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 tool's purpose: "Execute a scheduled task immediately." This uses a specific verb and resource, and distinguishes it from sibling tools like coolify_list_scheduled_tasks (which lists) and coolify_create_scheduled_task (which creates). The action is unambiguous and directly differentiated.

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 when to use the tool (when you need to trigger a scheduled task right now) but provides no explicit alternatives or exclusions. It does not compare with similar action-oriented tools like coolify_deploy or coolify_restart, nor does it mention conditions under which it should not be used, aside from vague policy restrictions.

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

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

Annotations already declare read-only/idempotent/non-destructive. The description adds meaningful behavioral context: configurable line count capped by COOLIFY_LOG_MAX_LINES, and that secrets are redacted. This goes beyond annotations.

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

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

The description is two sentences, front-loaded with the action, and every word adds value. No wasted content.

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, annotations, and full schema coverage, the description is adequately complete. It covers key behavioral details (line cap, redaction) but could mention return format since there is no output schema.

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 parameters (application_uuid, lines) are fully described in the schema. The description's mention of 'configurable line count' adds minimal extra meaning, as the schema already documents the default and max.

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 application logs', which is a specific verb+resource combination. It also distinguishes from sibling log tools by explicitly mentioning 'application' (vs database/service logs).

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

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

The description implies usage: when you want application logs. However, it does not explicitly differentiate from sibling tools like get_database_logs or get_service_logs, nor does it provide when-to-use vs alternative guidance.

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

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

Annotations already declare it as read-only, non-destructive, and idempotent. The description adds value by specifying the return fields (id, name, permission scope), giving the agent a concrete idea of what to expect. No additional side effects or caveats are necessary for a simple getter.

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 that starts with the action and lists the key return fields. Every word earns its place, with no filler or redundancy.

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

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

Given the tool's simplicity (no parameters, no output schema, clear read-only role), the description fully covers what the agent needs to know: what it does and what it returns. No additional edge cases or error handling are necessary.

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

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

The tool accepts zero parameters, so the description has no burden to explain parameter meanings. The baseline for zero parameters is 4, and the description provides no conflicting or redundant details. It simply states what is returned, 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 clearly states the tool retrieves the current team context and specifies the exact fields returned (id, name, permission scope). It uses a specific verb (Get) and identifies the resource, distinguishing it from siblings like list_team_members.

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

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

The description provides clear context that this tool is for the current team, implying use when you need the active team's details. However, it doesn't explicitly contrast with alternatives such as list_team_members or list_projects, so it lacks explicit exclusions while still being clear enough for typical usage.

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

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

The annotation declares readOnlyHint=true and idempotentHint=true, so the read-only nature is already covered. The description adds a valuable behavioral detail: 'Secrets are redacted,' which is beyond what annotations provide. This is useful context for the agent.

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

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

The description is two short sentences: 'Get database container logs. Secrets are redacted.' Every word adds value, with no redundancy or fluff.

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

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

For a simple read-only log-fetching tool with high schema coverage and annotations, the description is adequately complete. It covers the core function and a key behavior (redaction). It does not describe output format or default line counts, but these are either specified in the schema (lines default) or not critical for execution.

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 'database_uuid' and 'lines' having descriptions in the schema. The tool description does not add additional parameter meaning, but the schema already documents them well, 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 clearly states 'Get database container logs' with a specific verb and resource. It distinguishes from sibling tools like get_application_logs and get_service_logs by explicitly targeting database logs.

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

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

The description indicates the tool is for database container logs, which implies when to use it, but it does not explicitly mention alternatives or exclusions. The sibling tool names suggest differentiation, but the description itself lacks direct guidance on choosing this over get_service_logs or get_application_logs.

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

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

The description adds value beyond the annotations by disclosing the return content (status, timestamps, commit info, error summary). Annotations already declare readOnly, idempotent, and non-destructive behavior. There is no contradiction, and the added detail is useful for understanding what the tool provides.

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 concise, front-loaded sentence with a colon introducing the key data points. Every word earns its place, and the structure is clear and scannable.

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

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

For a simple read-only tool with a single parameter, the description is complete. Annotations cover safety, schema covers the parameter, and the description covers return values. No output schema exists, but the listed return fields suffice. The simplicity of the operation does not require more.

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 covers 100% of the parameter (deployment_uuid) with a clear description. The tool description only reiterates 'by UUID', adding no new meaning. With full schema coverage, the baseline of 3 applies.

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

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

The description clearly states the tool gets a deployment detail by UUID, listing the specific data points (status, timestamps, commit info, error summary). It uses a specific verb ('Get'), identifies the resource ('deployment detail'), and distinguishes from siblings like coolify_list_deployments by specifying a single deployment lookup.

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 makes it clear this is for retrieving a single deployment by UUID, implying it is for specific deployment details rather than listing or mutating. However, it does not explicitly mention alternatives or when not to use it, though sibling tool names provide 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is fully covered. The description adds no extra behavioral context (e.g., return format, errors), but for a simple getter this is acceptable given the annotations.

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

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

The description is a single, concise sentence that is front-loaded with the key information. Every word earns its place with zero unnecessary detail.

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 simplicity of the tool (single parameter, no output schema), the description is sufficient. It clearly states what is returned (a single destination by UUID), though it doesn't detail the return structure, which is not critical for a simple getter.

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 provides a complete description of the only parameter (destination_uuid: 'Destination UUID'), covering 100% of the schema. The tool description adds no additional semantic value 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 uses the verb 'Get' with the resource 'destination' and specifies the unique identifier (UUID), making its purpose obvious and distinguishing it from sibling tools like list_destinations and create_destination.

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 using this tool when you need a single destination identified by UUID. While it doesn't explicitly exclude alternatives or mention when-not-to-use, the sibling context (list/create) makes the usage context clear.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is clear. The description adds behavioral context about the response contents ('environments and resource counts'), which goes beyond what the schema or annotations provide. No contradiction with annotations.

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

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

The description is a single, compact sentence that conveys the essential information without any wasted words. It is front-loaded with the verb and resource, making it immediately scannable.

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?

This is a simple read-only tool with one parameter, strong annotations, and no output schema. The description tells the agent what it returns (environments and resource counts), which is sufficient for basic usage. A slightly richer description could mention not-found behavior or return format, but the tool's simplicity keeps this complete enough.

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

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

The input schema has a single parameter with a description ('Project UUID') and 100% schema description coverage. The tool description echoes 'by UUID' but does not add any new semantic detail beyond the schema, 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 uses a specific verb 'Get' with a clear resource 'project' and scope 'by UUID with its environments and resource counts'. This distinguishes it from sibling tools like list_projects (which lists all projects) and project_overview, making the purpose 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 clearly implies when to use this tool (when you need a single project by UUID with its environment and resource count details). However, it does not explicitly name alternatives or state when not to use it, so it falls short of the 'explicit when/when-not/alternatives' bar.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description adds value by noting 'Sensitive fields are redacted,' which informs the agent that the response will omit certain information. This goes beyond what annotations provide and is important since there is no output schema.

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

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

The description is only two sentences, both of which carry meaningful information. It is front-loaded with the core action and includes a crucial transparency note. No wasted words or redundancy.

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

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

For a simple getter with two well-documented parameters and strong annotations, the description is complete. It covers the essential purpose and the redaction behavior. It does not detail the response structure, but with no output schema, that might be expected; still, the lack of guidance on not-found behavior or response format slightly prevents a 5.

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 has 100% description coverage for both parameters, including the enum for type and pattern for uuid. The description only restates 'by UUID and type,' adding no new meaning beyond the schema. 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 clearly states the tool's function: 'Get a single resource detail by UUID and type.' This specifies the verb, resource, and method of identification, and distinguishes it from sibling list/get tools by emphasizing 'single' resource. The addition of 'Sensitive fields are redacted' also clarifies a key aspect of the response.

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 when to use the tool (when you have a UUID and type for a specific resource) but does not explicitly mention alternatives or exclusions. For example, it doesn't say 'use list_resources to get all resources.' The guidance is only implied by the tool's purpose, not 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?

Annotations already declare readOnly, idempotent, and non-destructive behavior. The description adds valuable context about SSH keys and sensitive network info being redacted, which goes beyond annotations and helps set expectations.

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 front-loads the core action and includes a useful behavior note without any waste or redundancy.

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

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

For a simple getter with one parameter and no output schema, the description covers the action and a key behavioral trait (redaction). The lack of error handling or return value details is a minor gap, but overall sufficient for the tool's simplicity.

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

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

Schema coverage is 100% with the 'uuid' parameter already described as 'Server UUID'. The description only restates 'by UUID' without adding additional format or usage details, so a 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 'Get a single server detail by UUID' uses a specific verb and resource, clearly distinguishing from sibling tools like list_servers via the 'single' scope. It also mentions redaction, adding further specificity.

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 context is only implied through the name and 'single' scope; there is no explicit guidance on when to use this over list_servers or validate_server, nor any mention of exclusions or 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description adds value by noting that secrets are redacted. However, it does not describe the return format, pagination behavior, or any other behavioral details, which is noticeable since no output schema is provided.

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

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

The description is two short sentences with no filler. It states the core action and adds the useful caveat about secret redaction. Every word earns its place.

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

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

For a simple read-only log-fetching tool with good annotations and full schema coverage, the description is mostly sufficient. It lacks details about the output format, but this is a minor gap given the tool's simplicity.

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

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

Schema description coverage is 100% and both parameters have clear descriptions (service_uuid and lines with default/cap). The description adds no additional meaning beyond the schema, so the 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 ('Get') and the resource ('service container logs'), which is distinct from sibling tools like get_application_logs and get_database_logs. However, it does not explicitly mention those alternatives, so it slightly misses the full 5 criteria.

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

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

The description implies this is the tool for service logs, but it does not explicitly state when to use it over alternatives or any exclusions. The value is mostly inferred from the tool name and schema.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so safety is known. The description adds the key behavioral trait 'Output is redacted for security,' which is not captured by annotations. This is valuable context beyond structured data.

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, front-loaded with the action 'Get,' and includes an important security caveat without unnecessary words. Every element 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 read-only tool with comprehensive schema descriptions and strong annotations, the description fully covers purpose and security redaction. No output schema exists, so return values need not be explained. The description is complete for its context.

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

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

The input schema provides descriptions for all 5 parameters (100% coverage), so the description does not need to explain them. Since the description adds no additional parameter semantics, 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 and resource: 'Get execution history for a scheduled task.' This clearly distinguishes it from sibling tools that list scheduled tasks or execute them, and the name reinforces the scope.

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

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

The purpose statement establishes clear context for when to use the tool (to retrieve execution history for a scheduled task), but it does not explicitly mention exclusions or alternative tools. This is acceptable given the clarity of the resource and action, earning a 4 rather than 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds no further behavioral context such as response format or error scenarios, so it provides no value beyond the annotations.

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

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

A single sentence that fully states the tool's purpose with no redundant wording. It is appropriately concise 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?

For a parameterless, read-only tool with strong annotations, the description is fully sufficient. While there is no output schema, the operation is simple enough that no additional context is required.

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

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

The tool has zero parameters and an empty schema. The description correctly avoids parameter details, and the baseline of 4 for 0-parameter tools applies.

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

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

The description uses a specific verb 'Get' and clearly identifies the resource 'Coolify instance version'. It is unambiguous and distinguishes from sibling tools like health, which is a different type of check.

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 explicit guidance on when to use this tool versus alternatives, nor does it mention exclusions. Usage is implied for a simple read operation, but there is no stated context or alternative differentiation.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safe-read nature is covered. The description adds behavioral context by specifying the response content (health status, auth status, latency) and guaranteeing 'No secrets in response,' which is valuable beyond the annotations. No contradictions.

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

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

The description is three short sentences, each earning its place: the first states the primary action, the second lists expected outputs, and the third adds a security guarantee. It is front-loaded and free of unnecessary words.

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

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

For a simple health check with no parameters and no output schema, the description is fully sufficient. It explains what the tool does, what it returns, and reassures about sensitive data. There are no gaps in context for an agent 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?

The tool has zero parameters, so the baseline is 4. The description adds meaning by explaining the operation and return values, which is all that is needed since there is nothing to document about parameters. No param info is missing.

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 specific verb and resource: 'Check Coolify API and MCP server connectivity.' It also lists what it returns (health status, auth status, latency), making it distinct from sibling tools that create or manage resources. This is a dedicated health check tool with an unmistakable purpose.

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 for verifying connectivity before other operations, but it does not explicitly state when to use it over alternatives or include any exclusions. There is no mention of alternative tools or conditions that would make this tool inappropriate, so guidance is only implied rather than explicit.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is clear. The description adds a valuable behavioral detail: 'Output is redacted for security,' which explains why the returned data may be incomplete or masked. This goes beyond the annotations without contradicting them.

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

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

The description is a single, front-loaded sentence that immediately states the verb ('List') and resource, with no filler or redundant information. Every word earns its place.

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

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

For a simple read-only listing tool, the description covers the purpose, the required scope (scheduled backup configuration), and a notable output behavior (redaction). While there is no output schema, the description is reasonably complete for the tool's simplicity, though it could optionally mention the return format (list of execution records).

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 provides full descriptions for all three parameters (database_uuid, scheduled_backup_uuid, limit), so the description adds no parameter-specific meaning beyond what's already in the schema. This meets the baseline of 3 for high 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 action ('List backup executions') and the specific resource ('for a scheduled backup configuration'). It distinguishes itself from sibling tools like coolify_list_database_backups (which lists backup configs) and coolify_get_task_executions (generic task executions), making its purpose 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 usage context by mentioning 'for a scheduled backup configuration', but it does not explicitly state when to use this tool versus alternatives like get_task_executions or list_database_backups, nor does it provide exclusions or prerequisites. This is implied usage, not explicit guidance.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true, covering the safety profile. The description adds minimal extra context ('via a GitHub App') but does not disclose potential pitfalls like pagination or error modes. No contradiction with annotations.

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

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

A single sentence with no redundant words. The description is front-loaded with the action ('List') and resource ('branches'), making it highly scannable and efficient.

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

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

For a simple, read-only list operation with clear parameters and annotations, the description is mostly sufficient. However, with no output schema, it does not state what the return value looks like (e.g., array of branch names), which is a minor omission.

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 (owner, repository, github_app_uuid) has a clear description. The tool description adds no additional meaning beyond the schema, so a 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 uses the specific verb 'List' and clearly identifies the resource as 'branches of a GitHub repository via a GitHub App'. This makes the tool's purpose unmistakable and distinguishes it from sibling tools like list_repositories or list_github_apps.

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 use when branch listing is needed and mentions the GitHub App authentication context, but provides no explicit guidance on when not to use it or which alternatives to prefer. It is a basic list operation, so some context exists, but exclusions are missing.

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

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

Annotations already indicate read-only, idempotent, non-destructive behavior. The description adds valuable context that 'Sensitive destination paths are redacted,' which is not captured by annotations. This is a useful disclosure about output behavior, so the description contributes beyond the structured metadata.

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 that states the core functionality and one key exception. No filler words or redundant information. It is appropriately sized for the tool's simplicity.

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 list operation with good annotations and full schema coverage, the description is mostly complete. It explains the action and adds redaction behavior. However, the ambiguity with the sibling tool reduces its completeness, as the agent may need more context to choose correctly, though this is more of a usage guideline issue.

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 covers 100% of the single parameter 'database_uuid' with a clear description 'Database UUID.' The tool description does not add further parameter details, but since the schema already provides sufficient semantics, a 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 uses a specific verb and resource: 'List backup executions for a database.' It clearly states the action and target. However, it does not differentiate from the sibling tool 'coolify_list_backup_executions', which sounds similar, so it does not fully distinguish itself.

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 given on when to use this tool versus alternatives like 'coolify_list_backup_executions' or other backup-related tools. There are no prerequisites, exclusions, or alternative references, leaving the agent to infer usage from the description alone.

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

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

Annotations already declare read-only, idempotent, and non-destructive behavior, so the burden is lower. The description adds the 'Newest first' ordering detail, which is not encoded in the schema or annotations. However, it does not disclose return format, pagination, or default behavior when no filters are given.

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

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

The description is a single sentence that front-loads the action and resource, lists filters compactly, and includes the sorting order. Every word contributes value, with no redundancy or fluff.

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

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

For a simple list operation with strong annotations and full parameter schema, the description covers the essential purpose and ordering. It lacks explicit return structure, but the action 'list' implies a collection of deployments. It is adequate for basic invocation, though a bit more detail on response shape would improve it.

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%, with each parameter having a descriptive comment. The tool description merely names the filters without adding any extra meaning, examples, or constraints beyond what the schema already provides. Baseline of 3 applies due to high 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 uses the specific verb 'List' with the resource 'deployments' and enumerates the available filters, making it clear this is a query operation for multiple deployments. It also specifies sorting order ('Newest first'), distinguishing it from single-deployment retrieval or cancellation 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 use when a user needs to list or filter deployments, but it does not explicitly reference alternative tools like fetching a single deployment or canceling one, nor does it state when not to use it. There is no comparison to sibling tools or exclusion conditions.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is established. The description adds the team scoping constraint, which is useful behavioral context, but does not mention pagination, ordering, or return format. This is consistent with no contradictions.

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 that states exactly what the tool does without any filler. 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 complete for a zero-parameter list tool with no output schema. It specifies the resource type and scope ('Docker network destinations' for the 'authenticated team'), which is sufficient context for an agent to understand what the tool 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?

There are zero parameters, so the schema coverage is trivially 100% and no parameter explanations are needed. The description adds no parameter details, but that is appropriate given the tool takes no arguments.

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

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

The description uses a specific verb 'list' with a clear resource 'Docker network destinations' and scope 'for the authenticated team'. It effectively distinguishes from siblings like get_destination (single item) and create_destination.

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 when to use it (to list destinations) and provides context via the team scoping, but it does not explicitly mention alternatives or exclusions. For a simple list tool, the context is clear enough.

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

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

Annotations already establish read-only and non-destructive behavior, so the description does not need to repeat that. The description adds valuable transparency by explicitly stating that values are never returned, which is a behavioral guarantee beyond annotations. This is especially useful for agents handling sensitive data, but it doesn't detail the metadata format further.

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

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

The description is compact and front-loaded: a single clear purpose sentence followed by a critical caveat. Every word earns its place, with no redundant filler or repetition of schema/annotation info.

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

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

For a simple read-only listing tool, the description covers the essential context: what it lists, that values are excluded, and the resource scope. The optional environment_name parameter is only labeled 'informational' in the schema, and the description does not clarify whether it filters results, which is a minor gap. Overall, it's sufficient for most use 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?

The schema already covers all three parameters with descriptions (resource_uuid, resource_type, environment_name). The description adds no additional parameter-level detail or semantics beyond what the schema provides, so baseline 3 is appropriate for this high 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 action (List) and the resource (environment variables for a resource), with a specific scope statement. The addition 'Returns keys and metadata only — VALUES ARE NEVER RETURNED' provides essential distinction from sibling tools like set_environment_variables, clarifying its purpose.

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 clearly conveys when to use this tool: whenever you need to see environment variable keys/metadata for a resource. It also implies that values are not available here, signaling that this is not the tool for retrieving secret values. However, it does not explicitly name alternative tools or exclusion criteria, so it stops short of perfect guidance.

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

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

Annotations already declare readOnlyHint, destructiveHint, and idempotentHint, covering the safety profile. The description adds that the result includes team and system-wide apps, which is useful scope context, but it does not disclose additional behaviors like pagination or rate limits. This mirrors the get_calls example, so a 3 is appropriate.

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

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

The description is two sentences with no redundancy. It front-loads the primary action and provides the key output detail (team and system-wide apps) efficiently, earning every word.

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 parameter-less list tool with strong annotations, this description is complete. It states the resource and output scope, and since no output schema exists, the mention of 'team and system-wide apps' gives sufficient return-value context. The sibling list makes the tool's niche clear.

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

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

The tool has zero parameters, so the schema provides complete coverage. With 0 params, the baseline is 4 per the rubric; the description does not need to explain inputs, and it correctly focuses on what the tool returns.

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

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

The description uses the specific verb 'List' with the resource 'GitHub Apps' and clearly differentiates from sibling tools by noting it returns team and system-wide apps. The scope is explicit and distinguishes it from other list tools like coolify_list_repositories.

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 for retrieving connected GitHub Apps but provides no explicit guidance on when to choose this tool over alternatives. There are no exclusions or alternative recommendations, leaving the agent to infer the appropriate 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?

The annotations declare readOnlyHint, idempotentHint, and destructiveHint, so safety is already covered. The description adds a key behavioral detail: credential values are never exposed, which helps the agent set expectations about sensitive information in the response.

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

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

Two concise sentences with the main action front-loaded. The first sentence tells exactly what it does; the second adds an important caveat. 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?

This is a simple tool with one optional parameter and rich annotations. The description explains the purpose and a critical security aspect. Without an output schema, the description is sufficiently complete for an agent 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?

The input schema fully describes the only parameter ('channel') with an enum and description, achieving 100% coverage. The tool description does not need to repeat this; per baseline, a 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 clearly states the tool's function with a specific verb+resource: 'List notification channel settings.' This distinguishes it from sibling tools like 'coolify_list_servers' or 'coolify_list_projects.'

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

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

The description gives clear context: it lists notification settings, so you would use it whenever you need to inspect current notification channels. It does not explicitly mention alternatives, but no exclusion is necessary given the tool's simple, read-only nature.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true, so the safety profile is clear. The description adds the optional name filter behavior, but this is also present in the input schema, so it does not provide substantial context beyond annotations. No mention of pagination, output format, or rate limits.

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 redundant words. It efficiently states the action, target, and optional modifier.

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?

This is a simple read-only list tool with one optional parameter and strong annotations. The description is sufficient for a tool of this complexity, though an explicit note about return format would be slightly more complete, but it is not critical given the obvious 'list' semantics.

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

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

The schema has 100% description coverage for the single parameter 'name', and the description itself just reiterates 'optional name filter' without adding new meaning. Baseline score of 3 is appropriate since the schema carries the 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?

The description clearly states the verb (List) and resource (Coolify projects), and specifies the scope as 'all' with an optional filter. This distinguishes it from sibling tools like coolify_get_project (which retrieves a single project) and coolify_create_project (which creates a new 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 implies use for retrieving a collection of projects, but it does not explicitly state when to use this over alternatives like coolify_get_project or coolify_list_resources. No exclusions or alternative tool names 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 annotations (readOnlyHint, idempotentHint, destructiveHint) already establish this as a safe, non-destructive operation. The description adds that pagination and search are supported, which is useful behavioral detail, but it doesn't disclose other traits like rate limits or return format.

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 concise, using two short sentences that front-load the primary purpose and mention key features. Every word contributes.

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

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

For a straightforward list operation, the description is adequate: it specifies the resource type and the filter scope. Combined with the detailed schema and annotations, the context is sufficient, though no output schema exists to detail the return shape.

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 provides descriptions for all four parameters, giving 100% coverage. The description's mention of pagination and search reinforces the purpose of the page, limit, and search parameters, but adds limited new meaning 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 tool's function: listing repositories accessible via a GitHub App. It uses a specific verb and resource, and distinguishes itself from sibling tools like list_branches or list_github_apps by specifying the GitHub App scope.

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

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

The description provides clear context for when to use the tool—when you need repositories accessible through a specific GitHub App. It doesn't explicitly mention alternatives or when not to use it, but the context is sufficiently clear.

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

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

The description adds the filter list, which is behaviorally relevant, but the read-only and idempotent nature is already disclosed by annotations. No additional behaviors like pagination or ordering are described.

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, efficient sentence that front-loads the action and lists filters. Every word earns its place, with no redundancy.

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

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

For a simple filter list with strong annotations and full schema coverage, the description is nearly complete. It clearly states the function and filters, though it omits details about return value or pagination, which are not critical given the context.

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

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

The schema already includes comprehensive descriptions for all five parameters (100% coverage). The tool description merely lists the parameter names without adding new semantic details, 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 clearly states the tool's action (list) and resource (resources), and enumerates the filter parameters. This differentiates it from sibling tools like coolify_list_servers (lists servers) and coolify_get_resource (gets a single resource).

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

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

The description implies this is the general resource listing tool with filters, but does not explicitly state when to use it vs alternatives. No mention of when to prefer coolify_list_server_resources or coolify_project_overview.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true, covering the safety profile. The description adds 'Returns current tag and available image tags', which is useful output context but not a behavioral trait like side effects or permissions. No additional behavioral disclosures are provided beyond the annotations.

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

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

The description is a single sentence that front-loads the action and includes the key return information. Every word earns its place, and there is no redundancy or padding.

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

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

For a one-parameter read-only tool with strong annotations and no output schema, the description adequately explains what the tool does and what it returns ('current tag and available image tags'). It is complete enough for an agent to select and invoke the tool 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?

The input schema provides a description for application_uuid ('Application UUID') with 100% coverage. The description does not mention the parameter, but the schema already handles its meaning. With high schema coverage, 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 'List available Docker images for rolling back an application', using the specific verb 'List' and resource 'Docker images for rolling back'. This distinguishes it from sibling tools like coolify_rollback_application, which actually performs the rollback, and other list operations.

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 phrase 'for rolling back an application' implies when to use the tool, but it does not explicitly state when to use it vs alternatives, nor does it mention that coolify_rollback_application would be the follow-up action. No exclusions or alternative recommendations are provided, so usage guidance is only implied.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds the valuable behavioral disclosure that 'Credentials are NEVER returned', which is not captured by annotations and is important for security expectations. It also clarifies the team scope.

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

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

Two short sentences, front-loaded with the main action, and every phrase adds value. No filler or redundancy.

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

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

For a simple list operation with one optional parameter, the description is largely complete. It covers scope, optional filtering, and the critical security caveat about escaping credentials. No output schema exists, so return value details are not required, though pagination or field details could add richness.

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 the 'name' parameter already has a clear description ('Filter S3 storages by name (case-insensitive partial match)'). The description merely repeats 'optional name filter' without adding further meaning, so it stays at the baseline 3.

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

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

The description clearly states the verb 'List', the resource 'S3 storages', the scope 'for the authenticated team', and the optional 'name filter'. This distinguishes it from sibling tools like coolify_create_s3_storage or coolify_validate_s3_storage, and the 'S3' qualifier disambiguates from coolify_list_storages.

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 context (authenticated team, optional name filter) but does not explicitly state when to use this tool versus alternatives such as coolify_list_storages or other list tools. There is no mention of when not to use it, so guidance is implied rather than explicit.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds minimal behavioral context beyond the annotations, such as implying the operation is safe and non-mutating, but does not disclose pagination, ordering, or response format. No contradiction with annotations.

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

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

The description is a single, directly worded sentence that conveys the essential operation without any redundancy or filler. It earns its place 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?

For a simple listing tool with read-only annotations and no output schema, the description is adequate. It identifies the key scope (application or service) and the action. It could mention the return type (list of task definitions) or any default behaviors, but these are not critical for the tool's simplicity.

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

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

Schema description coverage is 100%, with both parameters already described in the schema. The phrase 'for an application or service' mirrors the resource_type enum but adds no additional semantic detail 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 clearly states the action (List) and the resource (scheduled tasks) with a scope ('for an application or service'). It implicitly distinguishes from sibling tools like get_task_executions by focusing on the tasks themselves rather than their executions, but does not explicitly name alternatives.

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. The description provides no explicit context about selecting this over get_task_executions or other tools, nor does it mention any prerequisites or filtering options.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true, so the safety profile is well covered. The description adds no further behavioral context, such as return format or pagination, but does not contradict annotations. With annotations present, a baseline of 3 is appropriate.

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 redundancy. Every word adds value, making it highly concise and 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?

For a simple, read-only tool with one parameter and strong annotations, the description is complete. It clearly states what the tool returns (a list of domains) and the input scope (a server). No output schema exists, but the nature of the tool makes the return value obvious. The description is sufficient for the tool's complexity.

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

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

The schema covers the only parameter (server_uuid) with a clear description ('Server UUID'), and schema coverage is 100%. The description itself does not add semantic detail beyond referencing the server, but the baseline of 3 applies when 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 uses a specific verb ('List') and resource ('domains') with an explicit scope ('associated with a server'). This clearly distinguishes it from sibling tools like list_servers or list_server_resources, which target different resources.

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 makes the tool's purpose clear but provides no explicit guidance on when to use it versus alternatives. Its usage is implied: to retrieve domains for a specific server. No exclusions or alternative references are given, so it does not fully meet a 'clear context with exclusions' standard.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description adds that results are scoped to a specific server, which is a useful behavioral context, but it does not disclose response format or any other operational details.

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

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

The description is a single sentence with 13 words, front-loaded with the verb 'List' and including the key scoping detail. There is no redundant information.

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