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

With no annotations, the description must carry the full behavioral burden. It usefully discloses that the return includes the key and secret, but it omits permissions required, side effects, and whether existing keys are affected.

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 front-loaded with the purpose, then cleanly separates Args and Returns. Every sentence is relevant and there is no wasted text.

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

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

For a simple one-parameter create tool with an output schema, the description covers purpose, parameter, and return value. It misses usage guidelines and deeper behavioral context, but overall it provides what an agent needs to 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?

Schema description coverage is 0%, so the description must compensate. It documents the single parameter as 'Name/label for the API key', which is clear and sufficient for a simple string input, though no format constraints are given.

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

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

The description states a specific verb (Create) and resource (API key) and scopes it to the current user. It clearly distinguishes this tool from siblings like komodo_list_api_keys and komodo_delete_api_key.

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

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

Usage is implied by the tool's name and purpose: create a new API key when needed. However, the description does not state when to use this tool versus alternatives, nor does it mention prerequisites or exclusions.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not disclose whether this is a dry-run or a real mutation, what required permissions or server connections are needed, what happens on duplicate names, or any side effects. Only 'Returns: Created build information' hints at a write 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?

It is short and front-loaded, but the Args/Returns boilerplate is generic and the extreme brevity reflects under-specification rather than crispness. No waste, but little value per 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?

The tool accepts a required nested config object with no documentation, has no annotations, and no output schema explanation beyond a one-liner. For a mutation that is part of a large CRUD family, this is insufficient for correct invocation.

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

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

The single parameter is a free-form object with 0% schema description coverage, so the description must compensate. It says only 'Build configuration dictionary,' providing no key names, formats, or examples. The agent cannot construct a valid config from this.

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 build,' which is a clear verb+resource. However, it does not distinguish this create from sibling update/delete/build-run tools, and it gives no sense of what a 'build' config contains. Adequate but generic.

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

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

There is no when-to-use guidance, no mention of prerequisites, and no routing to siblings like komodo_update_build or komodo_run_build. The agent gets no help deciding between create vs update vs run.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses nothing: no permission/auth requirements, no side effects, no indication of what happens on failure or conflict. For a mutation tool this is a complete gap.

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

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

Front-loaded with the purpose in the first line, which is good. The 'Args'/'Returns' boilerplate is largely wasted since the schema documents the parameter and an output schema exists, making the 'Returns' line redundant.

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?

Output schema presence means return values need not be explained, but the opaque nested 'config' object with 0% coverage is the critical missing piece, and there is no lifecycle or prerequisite context. The description is far too thin for a creation tool with a complex structured parameter.

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

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

Schema coverage is 0% and the single required parameter is a free-form nested object with additionalProperties. The description only restates 'Deployment configuration dictionary', adding no field names, required keys, or expected shapes, so the agent cannot construct a valid config.

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

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

States a clear verb+resource ('Create a new deployment'), which is unambiguous in isolation. However, it offers no differentiation from sibling creators like komodo_create_build or komodo_create_stack, so an agent must infer the boundary 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?

There is no guidance on when to create a deployment versus a build or stack, no prerequisites (e.g., a server must exist first), and no mention of alternatives such as komodo_run_deployment. The agent is left to guess the lifecycle ordering.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses almost nothing beyond the bare mutation. It does not say whether creation is idempotent, what happens on conflicting names, what permissions are needed, or what side effects (registration, health checks) occur.

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

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

Short and front-loaded, which is good, but the 'Args' and 'Returns' boilerplate lines carry essentially no information. The 'Returns' line is especially redundant given an output schema exists.

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?

An output schema exists so return values need no explaining, yet the description still spends a line on it while leaving the nested config object completely undocumented. For a required, free-form object parameter, this is a major gap.

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

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

Schema description coverage is 0% and the single parameter is a nested, open-ended object (additionalProperties: true). The description only restates the schema as 'Server configuration dictionary', giving no key names, no examples, and no required vs optional distinction — an agent has no way to construct a valid config.

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

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

States a specific verb and resource ('Create a new server'), which cleanly separates it from the sibling read (komodo_get_server / komodo_list_servers) and mutation tools. It does not, however, distinguish itself from komodo_create_deployment/build/stack beyond the resource noun, so sibling differentiation is only implicit.

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

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

There is no indication of when to use this tool versus komodo_update_server, komodo_delete_server, or the create/update variants for other resources. No prerequisites, auth requirements, or conditions are given.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it discloses nothing about permissions required, side effects, whether creation is idempotent, or what happens on name collision. The only behavioral hint is a generic 'Returns: Created stack information'.

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 core sentence is front-loaded and economical, but the boilerplate Args/Returns block adds almost no information for its length, and 'Args: config: Stack configuration dictionary' is pure restatement.

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

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

For a mutation tool with no annotations, a nested free-form object parameter, and zero schema coverage, the description is far too thin. The output schema covers returns, but nothing compensates for the undocumented creation semantics and config 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 single parameter 'config' is an arbitrary object with 0% schema description coverage, and the description only restates it as 'Stack configuration dictionary'. No keys, expected fields, or format are given, so the agent cannot construct a valid config from the description.

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

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

States a specific verb and resource ('Create a new stack'), which is unambiguous and separable from siblings like komodo_create_deployment or komodo_create_build by resource name. It does not, however, explicitly contrast itself with komodo_create_stack's natural siblings beyond the noun.

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

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

There is no guidance on when to use this tool versus alternatives, nor any prerequisites (e.g., authentication via komodo_login, needing an existing server). The agent must infer context entirely.

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

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

No annotations are provided, so the description carries the full burden. It never states that deletion is irreversible, whether an existing key can be recovered, or what authorization is needed - all critical for a destructive operation. 'Deletion confirmation' is the only behavioral hint and is redundant with the existing 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?

Short and front-loaded: the core action is the first sentence, with Args/Returns sections kept minimal. The boilerplate Args/Returns scaffolding is slightly wasteful given there is only one parameter and an output schema, but nothing is verbose.

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

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

For a destructive tool with no annotations and no guidance, the description is thin. The output schema covers return values, but the absence of any warning about irreversibility, permissions, or side effects leaves the agent without what it needs to invoke this safely.

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

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

Schema description coverage is 0%, so the description is the only source of parameter meaning. It does identify key_id as 'ID of the API key to delete', which the bare string schema does not, but adds no format, source, or example detail for the single parameter.

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

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

States a specific verb and resource ('Delete an API key'), so an agent can immediately tell it removes a key. It is not differentiated from siblings like komodo_create_api_key or komodo_list_api_keys beyond the name, but the action is unambiguous.

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

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

No guidance on when to use this versus alternatives, no prerequisites, no mention of required permissions or confirmation. The agent must infer that this is the destructive counterpart to komodo_create_api_key from the name alone.

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

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

With no annotations, the description carries the full behavioral burden for a destructive mutation, yet it discloses nothing about irreversibility, required permissions, or side effects. 'Returns: Deletion confirmation' is redundant given an output schema exists, so it adds no real transparency.

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 text is short and front-loaded, with the action stated first. The Args/Returns formatting is somewhat boilerplate given the output schema, but nothing is bloated.

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

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

For a destructive tool with no annotations and no schema descriptions, the definition is under-specified: no permission requirements, no irreversibility warning, no parameter format. The output schema covers the return value, so that omission is acceptable, but the destructive-operation context is missing.

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

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

Schema description coverage is 0%, so the description must compensate, but 'id: Build ID' merely restates the parameter name without format, source, or lookup guidance. It offers negligible 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?

States a specific verb+resource ('Delete a build'), which cleanly separates it from siblings like komodo_create_build, komodo_update_build, and komodo_get_build. However, it offers no scope detail (e.g., what a build is, whether deletion cascades) to further distinguish it.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives or when deletion is inappropriate. The agent gets zero routing help beyond the verb in the name.

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

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

With no annotations provided, the description carries the full behavioral burden. 'Delete' implies a destructive, presumably irreversible mutation, but the description does not state whether the operation is reversible, whether it requires elevated auth, whether it cascades to related resources, or what happens on failure. It only notes a 'Deletion confirmation' return, which the output schema already covers.

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 text is short and front-loaded with the purpose, and the Args/Returns structure is tidy. However, the brevity reflects under-specification rather than disciplined conciseness, and the Returns line is redundant with the existing output 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?

For a destructive single-parameter tool with zero annotation coverage, the description is too thin: it omits irreversibility, auth/permission needs, and failure behavior. The presence of an output schema excuses it from explaining return values, but not from the behavioral context a delete operation requires.

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

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

Schema description coverage is 0% and the single parameter has no type/format detail in the schema, so the description must compensate. 'id: Deployment ID' adds only marginal meaning beyond the parameter name, without specifying whether it is numeric vs string, a slug vs UUID, or where the agent obtains it.

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

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

The description states a specific verb (Delete) and resource (deployment), which cleanly distinguishes it from the sibling delete_build, delete_stack, and delete_server tools as well as from create/update/get/list variants. It is clear but offers no explicit sibling differentiation beyond the resource name embedded in the tool 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?

There is no guidance on when to use this tool versus alternatives (e.g., stop_deployment vs delete_deployment), no preconditions, and no note about what state the deployment must be in. An agent is left to infer entirely.

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

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

With no annotations, the description carries the full behavioral burden and largely fails: it doesn't state that deletion is destructive/permanent, whether it requires elevated permissions, or what collateral effects occur (e.g., associated deployments). The 'Returns: Deletion confirmation' line is the only behavioral hint.

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

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

Front-loaded with the action in one sentence and no filler. The docstring-style Args/Returns scaffolding is mildly redundant given the output schema, but overall tight.

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

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

For a destructive mutation with no annotations, the definition omits the safety context an agent needs (irreversibility, permission requirements, side effects). The output schema does relieve it of describing return values, but that alone doesn't make it complete.

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

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

Schema coverage is 0%, so the description must compensate; it does define the single parameter ('id: Server ID'), which clarifies what identifier is expected. It stops there, adding no format, source, or example for the ID.

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

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

States a specific verb+resource ('Delete a server'), which cleanly separates it from komodo_create_server and komodo_update_server. It doesn't name those siblings explicitly, but the verb alone is unambiguous.

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

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

No indication of when to use this versus alternatives, no prerequisites, and no warning that this is irreversible. The agent gets a bare operation with no decision context.

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

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

With no annotations, the description carries the full behavioral burden for what is a destructive mutation. It does not disclose whether the deletion is permanent, what happens to dependent resources, or any permission requirements. Only 'Deletion confirmation' hints at 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?

Front-loaded with the action and compact overall. The Args/Returns scaffolding is somewhat boilerplate but not wasteful.

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

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

An output schema exists, so return details are exempt, but for a destructive tool with zero annotations the description omits the destructive/permanence and safety context an agent needs. It is under-specified for the operation's risk level.

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

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

Schema description coverage is 0%, so the description must compensate, and it only adds 'Stack ID' for the single id parameter. That clarifies the identifier's meaning beyond the bare 'id: string' schema but provides no format, validation, or naming details.

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

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

States a specific verb and resource ('Delete a stack'), which distinguishes it cleanly from siblings like komodo_delete_deployment and komodo_delete_build. No explicit sibling routing is given, but the resource name alone is unambiguous.

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

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

No guidance on when to use this versus komodo_update_stack or other mutations, and no prerequisites or exclusions. The description only restates the action with no usage context.

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

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

No annotations are provided, so the description carries the full behavioral burden. For arbitrary command execution, it omits critical traits: permission/auth requirements, that it can mutate or destroy server state, and that it is effectively unconstrained. It only notes the return shape, which the output schema already covers.

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

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

Front-loaded one-line purpose followed by labeled Args/Returns sections with no filler. Slightly redundant to restate Returns when an output schema exists, but overall tight 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?

An output schema exists, so the return-value explanation is surplus, and parameters are well covered. However, with no annotations and an inherently destructive operation, the description leaves the safety/permission profile entirely unstated, which is a meaningful gap.

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

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

Schema description coverage is 0%, so the description must compensate, and it does: server is identified as the Server ID, command is given with examples ('ls -la', 'docker ps'), and options is expanded to working directory, timeout, and environment variables beyond the schema's bare open object.

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

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

States a specific verb (execute) and resource (command on a server via terminal), which is clearly distinct from the CRUD/run/stop siblings. It does not explicitly differentiate itself from siblings like komodo_run_build or komodo_run_deployment, but the arbitrary-command semantics are unambiguous.

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

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

There is no when-to-use or when-not-to-use guidance and no named alternatives. The agent must infer that this is for ad-hoc shell commands versus the dedicated run_deployment/run_build tools.

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

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

No annotations are provided, so the description carries full burden. It mentions 'configuration and status' which gives some idea of return content, but doesn't state whether this is read-only, requires auth, or what happens with invalid IDs. For a read tool this is minimally adequate.

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?

Very short and front-loaded with purpose. The 'Args' and 'Returns' sections are terse but not wasteful. However, the 'Returns' section is somewhat redundant since an output schema exists.

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?

An output schema exists, so the description needn't explain return values in detail, yet it provides a brief summary ('configuration and status') which is fine. However, for a tool with no annotations and a solo parameter at 0% schema coverage, the description lacks behavioral detail about auth or error conditions.

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

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

Schema description coverage is 0%, so the schema only provides the parameter name 'build' with no meaning. The description says 'build: Build ID', which restates the name and adds the word 'ID'. This is slightly better than nothing but insufficient compensation for a 0% coverage gap.

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

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

States a specific verb (Get) and resource (build), and the word 'specific' implies retrieval by identifier. It doesn't differentiate from komodo_list_builds or komodo_get_deployment, though the singular 'build' vs plural 'builds' helps.

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

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

No guidance on when to use this versus komodo_list_builds or how it relates to komodo_run_build/komodo_stop_build. The description simply describes the operation without routing the agent to the correct sibling.

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

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

No annotations are supplied, so the description carries the burden. 'Get detailed information' implies a safe read, and it discloses what is returned ('configuration and status'), but it says nothing about permissions, required auth (login/session context implied by sibling komodo_login), or error behavior for an unknown ID.

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

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

Front-loaded purpose sentence followed by clearly labeled Args and Returns sections; short and waste-free. The section labels add slight structural overhead but aid scanning.

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

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

For a single-parameter read tool with an output schema present, the definition is nearly sufficient: purpose, input identity, and a high-level return summary are all covered. The remaining gap is the lack of guidance on obtaining the deployment ID, which is minor.

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

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

Schema coverage is 0% and the single parameter has no description in the schema, so the description does the work by labeling it 'Deployment ID'. That is useful but minimal — no format, source, or example of where the ID comes from (e.g., komodo_list_deployments).

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

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

States a specific verb and resource ('Get detailed information about a specific deployment'), which clearly separates it from the sibling komodo_list_deployments. It does not, however, explicitly name the siblings it differs from, so sibling differentiation is left to inference.

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

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

No when-to-use guidance, no prerequisites, and no mention of alternatives such as komodo_list_deployments (to obtain the ID) or the get_stack/get_server counterparts. An agent can infer this is the detail lookup versus the list call, but nothing is stated.

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

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

No annotations are provided, so the description carries the full burden. It discloses that this is a read that returns configuration and status, which is useful, but it says nothing about authentication requirements, error behavior for invalid IDs, or whether the operation has side effects.

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

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

Front-loaded purpose sentence followed by short Args/Returns sections with no filler. The Args/Returns scaffolding is slightly heavier than needed for a single-parameter tool but earns its place by documenting the param and return.

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 single-parameter read tool, the description is nearly sufficient: purpose, parameter name, and a return summary are all present, and an output schema exists so return structure needn't be detailed. The missing pieces are param sourcing and auth/error 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?

Schema coverage is 0%, so the description must compensate; it labels the parameter as 'Server ID', which adds meaning beyond the bare string type. However, it doesn't indicate format, where to obtain the ID (e.g., from komodo_list_servers), or whether it is a name or numeric ID.

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

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

States a specific verb and resource: 'Get detailed information about a specific server.' This clearly separates it from komodo_list_servers (plural listing) and the create/update/delete server siblings, though it doesn't name those alternatives explicitly.

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

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

Usage is only implied by the word 'specific' — an agent can infer this is for fetching one server's details versus listing many. There is no explicit when-to-use, when-not-to-use, or prerequisite (e.g., valid server ID source) 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?

No annotations are provided, so the description carries full burden. It implies a read operation but doesn't state idempotency, permission requirements, or error behavior (e.g., what happens for a nonexistent stack ID). An output schema exists, so return-format disclosure is not required, but behavioral traits remain undocumented.

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?

Short and front-loaded, with the purpose stated first. The Args/Returns boilerplate is formulaic but not bloated, and the Returns line is redundant given an output schema exists.

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

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

For a single-parameter read tool with an output schema, the essentials are marginally covered: it says what it returns is stack info including configuration. But the parameter's origin and behavioral traits are unaddressed, leaving gaps an agent must fill by inference.

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 0% description coverage for the single 'stack' parameter, and the description only restates 'stack: Stack ID'. This adds no meaning beyond the name – no format, no examples, no note about where IDs come from (e.g., komodo_list_stacks). Description must compensate here and does not.

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

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

States a specific verb (Get) and resource (stack), and 'detailed information about a specific stack' clearly distinguishes it from the sibling list_stacks which enumerates stacks. It lacks explicit sibling naming but the read-vs-list distinction is implied by 'specific'.

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

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

No when-to-use guidance, no mention of alternatives like komodo_list_stacks or related get_* tools, and no prerequisites. The agent must infer usage from the name alone.

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

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

With no annotations, the description carries the full burden and it only partially delivers. It discloses the per-user scoping ('current user'), which is genuine behavioral info, but says nothing about read-only/safety nature, authorization requirements, or pagination for a list operation.

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

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

Front-loaded with the core action and kept brief. The 'Returns:' line slightly restates the purpose sentence ('List all API keys' vs 'List of API keys'), a minor redundancy, but overall tight 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?

An output schema exists, so return values needn't be spelled out, and a no-param list tool needs little else. The description is adequately complete, though it omits any note on auth context for the 'current user' scope.

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

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

The tool takes zero parameters, so the baseline is 4. There is no parameter surface for the description to document or mis-document.

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?

Clear verb (List) plus resource (API keys) with an explicit scope ('for the current user'). This naturally distinguishes it from the create/delete siblings, though it never names an alternative explicitly the way a 5 would.

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

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

There is no when-to-use/when-not guidance and no reference to sibling tools. The 'current user' scope is implied context but the description offers no conditions for selecting this over komodo_create_api_key or komodo_list_servers.

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

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

No annotations are provided, so the description carries the full disclosure burden. It does not mention pagination, ordering, authentication requirements, or result size, and only obliquely implies no filtering via 'all builds'. For a list endpoint with zero annotation coverage this is thin.

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 lead sentence is front-loaded and wastes nothing. The 'Returns:' sentence, however, largely restates the first line and is redundant given an output schema already exists, so it does not fully earn 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 zero-parameter list tool with an output schema, the description covers the essentials and need not explain return values. It is nonetheless missing any routing cue distinguishing it from komodo_get_build and the other list siblings, which is the main gap an agent would hit.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. No parameter claims are made that could mislead.

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

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

States a specific verb+resource ('List all builds'), which is unambiguous on its own and implicitly contrasts with the single-item komodo_get_build. However, it does not explicitly differentiate itself from the many other komodo_list_* siblings (servers, stacks, deployments, api_keys).

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

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

There is no guidance on when to use this versus komodo_get_build or the other list tools. The phrase 'all builds' weakly implies a bulk/overview use case, but no conditions or alternatives are stated.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It says nothing about pagination, scope (all servers/workspaces?), whether results are capped, or ordering — all of which matter for a 'list all' tool that could return a large collection.

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

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

Front-loaded with the action in the first two words, and the whole definition is only two short sentences. The 'Returns:' line is mildly redundant since an output schema exists, but it is not wasteful enough to penalize heavily.

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 an output schema present, the description needn't explain return values, and a zero-parameter tool has limited surface area. Still, for a collection-returning tool with no annotations, the absence of scope, pagination, and sibling-routing context leaves meaningful gaps.

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

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

The tool takes zero parameters, so there are no parameter semantics to document and the baseline of 4 applies. The description correctly implies no filtering arguments are accepted.

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

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

The description states a clear verb and resource ('List all deployments'), which is unambiguous on its own. However, it gives no signal distinguishing it from sibling 'komodo_get_deployment' or the other list_* tools, so an agent gets no help choosing among them.

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

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

There is no statement of when to use this tool versus 'komodo_get_deployment' (single deployment) or the create/update/delete variants. The implicit 'use this to enumerate everything' reading is left entirely to inference.

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

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

With no annotations provided, the description carries the full behavioral burden. It does not state that this is a read-only operation, whether results are paginated or filtered, or any rate or permission considerations. It only gives a minimal return note.

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 core action. The 'Returns' line is somewhat redundant given an output schema exists, but it is not wasteful enough to penalize heavily.

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

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

For a zero-parameter list tool with an output schema, the description covers what is needed to invoke it correctly. The only real gap is the absence of any routing hint distinguishing it from the single-server 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 tool takes zero parameters, so the baseline is 4. There is nothing for the description to clarify beyond the empty 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 states a verb and resource ('List all servers'), but the phrase essentially restates the tool name rather than adding clarifying scope. It makes no attempt to distinguish itself from natural siblings like komodo_get_server, which returns a single server.

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

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

No when-to-use context is given, and no alternatives are named. The agent must infer on its own that this is the bulk-enumeration counterpart to komodo_get_server.

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

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

No annotations provided, so the description carries the full burden. It doesn't disclose whether this is read-only (implied by 'List' but not stated), pagination behavior, or result size limits. The 'Returns' block restates the obvious.

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?

Very short and front-loaded with the core action. The 'Returns' block is largely redundant given a full output schema exists, but it's brief enough not to hurt.

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?

Output schema exists so return values needn't be explained, and there are no parameters. However, for a list tool in a large sibling set with no annotations, the description should at least confirm it's a read-only operation and any scoping (e.g., all stacks unconditionally).

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?

Zero parameters, so baseline is 4. No parameter semantics are needed and the description correctly doesn't invent any.

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

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

States a specific verb (list) and resource (stacks) clearly. Distinguishable from komodo_list_servers and komodo_list_builds by resource type, though the description doesn't explicitly differentiate beyond the resource 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?

No when-to-use guidance and no mention of alternatives like komodo_get_stack for detailed retrieval of a single stack. An agent must infer the distinction between listing and getting.

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

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

No annotations are provided, so the description carries the full behavioral burden. It doesn't disclose authentication failure behavior, whether the token expires or needs refreshing, whether credentials are transmitted securely, or rate limits on login attempts.

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

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

Front-loaded with the primary action and outcome in the first sentence. Well-organized with Args and Returns sections. Slightly verbose with the Returns section duplicating what the output schema already conveys.

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?

An output schema exists, so explaining return values is not necessary, yet the description does so. For a security-sensitive authentication tool with no annotations, more context on token lifecycle, error behavior, and credential handling would be valuable.

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

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

Schema description coverage is 0%, but the description compensates partially by labeling both parameters (username, password) meaningfully. However, it adds no format constraints, credential source guidance, or security handling notes beyond what the names imply.

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

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

States a specific verb (Login) and resource (Komodo), plus the outcome (obtain authentication token). It is clearly distinguished from all sibling tools, which are CRUD/list operations on servers, builds, deployments, and stacks.

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, and no prerequisites. It doesn't state that most other tools likely require the token this tool returns, nor does it warn against calling it repeatedly.

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

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

With no annotations, the description carries the full behavioral burden. It discloses only that execution returns 'result and status' but omits critical execution traits: whether the call blocks or is async/long-running, whether it needs auth, and whether it can be stopped. For an execution tool this is a notable gap.

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

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

The verb is front-loaded and the Args/Returns structure is easy to scan with no filler. It is slightly boilerplate but every line serves the definition.

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?

An output schema exists, so return-value explanation is appropriately light. Yet for a no-annotation execution tool, the description is incomplete on operational behavior (blocking vs async, auth, interaction with komodo_stop_build), leaving meaningful gaps for correct invocation.

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

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

Schema description coverage is 0%, so the description must compensate, and it largely does: it identifies 'build' as the Build ID to execute and 'options' as optional execution options with concrete examples (environment variables, timeout). This adds real meaning beyond the bare string/anyOf schema, though the options example remains loosely specified.

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

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

States a specific verb+resource ('Execute/run a build') that clearly distinguishes it from sibling mutation tools like komodo_create_build, komodo_update_build and komodo_delete_build. However, it does not name or contrast with the closest counterpart, komodo_stop_build, leaving the run/stop distinction to inference.

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

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

No when-to-use guidance, no preconditions, and no mention of alternatives. An agent is not told when to run a build versus stopping one (komodo_stop_build) or how run differs from komodo_run_deployment. Usage is only implied by the verb.

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

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

With no annotations, the description carries the full behavioral burden for what is clearly a mutating action. It does not state permission requirements, whether execution is synchronous or returns a job handle, whether it can be cancelled with komodo_stop_deployment, or idempotency. The brief mention of 'result and status' is the only behavioral signal, and an output schema already exists.

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

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

Front-loaded with the action, followed by a compact parameter and return breakdown. Minimal waste, though the explicit 'Returns' line partly duplicates the existing output 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?

The tool is adequately covered for its parameters and the output schema relieves the return-value burden. But as an unannotated mutation tool, it omits behavioral context an agent needs (permissions, sync vs async, cancellation via komodo_stop_deployment), leaving notable gaps.

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

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

Schema coverage is 0%, so the description must compensate, and it does: it identifies 'deployment' as the Deployment ID and clarifies 'options' as execution options with concrete examples (environment variables, timeout). This meaningfully exceeds the bare string/object schema, though the free-form options object remains only loosely specified.

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

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

States a specific verb and resource: 'Execute/run a deployment.' An agent can tell it is an action on a deployment. However, it does not differentiate from close siblings like komodo_create_deployment (which defines but presumably does not run) or komodo_stop_deployment, leaving the agent to infer the boundary.

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

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

There is no explicit when-to-use, when-not-to-use, or alternative routing. Given siblings that create, update, get, and stop the same resource, the description should say when this run action is appropriate versus create/stop, but it offers no 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?

No annotations are provided, so the description must carry the full behavioral burden. It only says a build is stopped and returns a confirmation, with no detail about permissions, side effects, reversibility, or what happens to the build state.

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 tightly front-loaded with the action, then cleanly structured into Args and Returns. Every sentence earns its place and there is no wasted text.

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

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

For a simple one-parameter action with an output schema, the description covers the basic purpose and parameter. However, with no annotations and no auth or usage context, an agent still lacks guidance on when it is safe or appropriate to stop a build.

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

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

Schema description coverage is 0%, but the description compensates for the single parameter by identifying it as the Build ID to stop. That gives enough meaning to correctly supply the required string identifier, though no format details are added.

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: stopping a running build. That is clearer than a vague purpose, but it does not explicitly distinguish itself from nearby siblings such as delete_build or stop_deployment.

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 implies use when a build is running, but gives no explicit when-to-use guidance or conditions for choosing it over alternatives like delete_build or run_build. There is no mention of prerequisites or state requirements.

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

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

With no annotations, the description carries the full behavioral burden but only says it stops a deployment and returns a stop confirmation. It does not disclose permissions, idempotency, side effects, whether the stop is graceful or forced, or whether it is reversible.

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

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

The description is short, front-loaded with the core action, and uses a clean Args/Returns structure. Every sentence earns its place without 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 (one parameter, output schema present), and the description covers the parameter and a return hint. However, for a mutation tool with no annotations, it lacks usage context and behavioral safety details that an agent would need to call it confidently.

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

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

Schema description coverage is 0%, so the description must compensate. It does so by clarifying that the single 'deployment' parameter is the Deployment ID to stop, adding meaningful semantics beyond the bare string type in 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 states a specific verb (Stop) and resource (running deployment), clearly distinguishing it from siblings like run_deployment, create_deployment, and delete_deployment. An agent can immediately tell 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?

Usage is implied by 'Stop a running deployment,' but the description provides no explicit when-to-use guidance, prerequisites, or alternatives such as delete_deployment or run_deployment. The agent must infer the context from the name and siblings.

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

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

No annotations are provided, so the description carries the full behavioral burden for a mutation tool. It does not say whether config is a full replacement or a merge, whether omitted fields are preserved, whether the build must be stopped first, or what errors can occur — all critical for a nested-dict mutation.

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 content is brief and front-loads the purpose, but the Args/Returns scaffolding is boilerplate and the return line is wasted because an output schema already exists. Half the text repeats structured data.

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

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

For a mutation tool with no annotations, a free-form nested config object, and 0% schema coverage, the description is far too thin — it gives no key inventory, merge semantics, or safety context. The presence of an output schema only excuses the return-value omission, which the description nonetheless includes.

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

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

Schema description coverage is 0%, so the description must compensate, but it only restates the parameter names ('Build ID', 'Updated build configuration dictionary'). The config object has additionalProperties=true and is nested, yet no valid keys, required subfields, or format are given.

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

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

States a specific verb and resource ('Update an existing build'), which cleanly separates it from the create/delete/get build siblings. It does not, however, distinguish itself from the other komodo_update_* tools or clarify what can be updated.

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

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

There is no when-to-use guidance: nothing says whether this replaces the whole build config, when it should be called instead of delete+create, or what prerequisites/permissions apply. Usage is only implied by the verb 'update'.

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

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

With no annotations, the description carries the full behavioral burden and it says only that an existing deployment is updated and updated info is returned. It doesn't disclose what happens to config keys not supplied, whether the update is partial or full replacement, permission requirements, or reversibility.

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?

Short and front-loaded with the action, but the Args/Returns docstring boilerplate is generic padding rather than useful content; no sentence is harmful, none adds much either.

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?

An output schema exists so return values need not be explained, but for a mutation tool with zero annotations and a free-form nested config object, the definition omits the details an agent needs to invoke it correctly.

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

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

Schema description coverage is 0%, so the description must compensate, but it offers only 'id: Deployment ID' and 'config: Updated deployment configuration dictionary'. The nested config object (additionalProperties=true) has no explanation of accepted keys or structure, leaving the most important parameter effectively undocumented.

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

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

States a specific verb and resource ('Update an existing deployment'), which is enough to distinguish it from list/get/create/delete_deployment siblings. It does not, however, differentiate itself from update_build/update_stack in any substantive way beyond the resource 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?

No when-to-use context, no prerequisites, and no mention of alternatives such as create_deployment or the run/stop_deployment siblings. The agent must infer the usage window entirely.

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

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

No annotations are provided, so the description carries the full burden. It says 'Update' but does not disclose whether this is a destructive overwrite, whether partial configs are merged, whether permissions are required, or whether the change is reversible. The minimal 'Returns: Updated server information' is the only behavioral hint.

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 text is short and front-loaded with the core action, which is good. But the Args/Returns scaffolding is boilerplate that occupies most of the content while adding little semantic value beyond the parameter names already in 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?

For a mutation tool with zero annotations, a 0%-covered nested-object parameter, and a large sibling set, the description is far too thin. It does not explain the config payload, mutation semantics, or how it differs from related tools, leaving major gaps an agent needs filled.

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

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

Schema description coverage is 0%, so the schema documents neither parameter in prose. The description names id and config but adds no meaning: it does not explain the format of the ID, what keys config accepts, or whether the config is partial or full-replacement. The nested object param is entirely unspecified.

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

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

States a clear verb+resource ('Update an existing server'), which is enough to distinguish from komodo_create_server and komodo_delete_server. However, it does not differentiate from the many sibling update_* tools or indicate what part of the server config is updatable, leaving the purpose only minimally specific.

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

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

No when-to-use or when-not-to-use guidance is provided. With 28 sibling tools, many offering create/get/delete/update variants, the description gives the agent no help deciding when this is the right tool versus alternatives like komodo_get_server or komodo_create_server.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only states the basic operation and that it returns updated stack information. It does not describe permission requirements, whether the update is partial or full, how unspecified fields are handled, or any side effects.

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

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

The description is short and front-loaded with the core purpose, using a standard Args/Returns structure. The Returns section is redundant given the presence of an output schema, but the overall text is efficient.

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

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

For a mutation tool with no annotations and a nested object parameter, the description is significantly incomplete. It does not explain the config structure, update semantics, or any behavioral details needed to invoke the tool correctly, despite the output schema covering return values.

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 description coverage is 0%, so the description must compensate, but it only restates the parameter names ('id: Stack ID', 'config: Updated stack configuration dictionary') without adding meaning beyond the schema types. It does not explain what keys the config object accepts or whether the update merges or replaces existing configuration.

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

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

The description states a clear verb ('Update') and resource ('existing stack'), so an agent can tell it apart from create_stack, delete_stack, and get_stack. However, it does not explicitly differentiate itself from sibling update tools for deployments, builds, or servers beyond the resource 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 provides no guidance on when to use this tool versus alternatives, no prerequisites for updating a stack, and no conditions under which it should not be used. It only states the operation, leaving context entirely to inference.

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