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

Annotations already declare destructiveHint=true, idempotentHint=false, and openWorldHint=true, so safety profile is covered. The description adds useful non-annotation context (edition/license/permission gating, 404 behavior on Community editions), but says nothing about what state changes, whether activation is reversible, or privilege requirements for the mutation itself.

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

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

Three short sentences, front-loaded with the action, then constraints, then body format. The final sentence is cryptic ('JSON-encoded string fields must remain strings') but not padded.

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

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

For a destructive, non-idempotent mutation with a required nested object and no output schema, the description omits success/failure semantics, what the key represents, and what the destructive effect actually is. The edition/license caveat is the only substantive addition.

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 required parameter is a nested body with a required 'key' field whose meaning the description never explains. 'Supply API fields in body' and the JSON-string warning gesture at the wrapper, but the agent still does not know what 'key' should contain (license key, subscription key, activation code).

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 ('activate subscription') and is distinguishable from siblings like get_subscription, refresh_subscription, and delete_subscription. It is slightly thin on what is actually being activated (a license key? an existing subscription record?), but the endpoint reference POST /subscription anchors 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?

The edition/license/permission caveat with 'some Community routes return 404 or empty lists' gives real context on when the call will work, which is more than most definitions offer. However, it gives no guidance on when to activate versus refresh_subscription or get_subscription, and no prerequisite steps.

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 destructiveHint=true, idempotentHint=false, readOnlyHint=false and openWorldHint=true, so the risk profile is covered structurally. The description adds no behavioral context beyond the raw endpoint: nothing about whether the attach replaces existing inventory associations, whether it is reversible, or what authorization is needed.

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

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

Two compact sentences with the action front-loaded and no filler. The second sentence is essentially a URL restatement, which is terse but of marginal value to an agent that already has the parameter list.

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, non-idempotent mutation with three undocumented parameters and no output schema, the description should say what changes as a result of the attach and what an agent should verify before calling it. Neither is present, leaving the definition thin 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 partially does: the path template maps each of the three integers to a role (a project, a template within it, an inventory to attach). It still gives no constraints, such as whether the inventory must be related to that project or what errors occur on mismatch.

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 restates the tool name ('Attach Inventory') and then gives the REST endpoint, which reveals that the operation links an inventory to a template within a project. That is more informative than the title alone, but it never states in plain language what 'attach' means for the objects involved. The existence of detach_template_inventory and set_template_default_inventory makes the distinction inferable but not explicit.

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 this should be used versus detach_template_inventory or set_template_default_inventory, and no prerequisites (e.g. that the inventory must already exist and belong to the project). The agent is left to infer usage entirely from the name and URL.

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 destructiveHint=true, idempotentHint=true, and openWorldHint=true, so the safety profile is covered by structured data. The description adds the endpoint path but never explains what actually gets destroyed or how the six scope booleans control which categories of cluster tasks are removed — the single most important behavioral fact for a destructive call. The "JSON-encoded string fields must remain strings" note is generic boilerplate that doesn't apply to the boolean fields here.

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

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

Three short sentences, so there is no bloat, but the first merely echoes the tool name and the third is a templated serialization note of dubious relevance to a boolean-only payload. Brevity here stems from omission rather than disciplined editing.

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, nested-object, zero-coverage tool with no output schema, the description leaves the critical questions unanswered: which scope flags must be set, whether the call is scoped to a cluster/node or global, and what the response confirms. Annotations cover the safety hints, but nothing else compensates for the missing 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?

With only one top-level parameter but 0% schema description coverage and six undocumented nested booleans (queue, active, claims, aliases, running, runtime_fields), the description needed to carry the meaning. Instead it offers only the generic "Supply API fields in body," adding nothing about what each scope flag selects or whether omitting a flag means 'not cleared' or 'clear all'.

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 Cluster Tasks" largely restates the tool name, and the only added specificity comes from the endpoint path "DELETE /cluster/tasks", which signals a purge operation. It never disambiguates from the large family of sibling clear/stop/delete tools (clear_project_cache, clear_global_runner_cache, stop_template_tasks, delete_global_task), so an agent cannot tell precisely what resource is purged or at what 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?

There is no statement of when to use this tool, when not to, or which sibling to prefer (e.g., list_cluster_tasks to inspect first, or stop_template_tasks vs. this purge). The only usage-ish instruction is "Supply API fields in body," which is a formatting note, 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 declare destructiveHint=true, idempotentHint=true, and readOnlyHint=false, so the safety profile is covered. The description adds nothing beyond restating the operation and the HTTP route; it does not say what is invalidated, whether jobs are interrupted, or whether the runner must be stopped.

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 terse sentences with the action front-loaded and no wasted clauses. The endpoint string adds little for an agent but costs almost nothing.

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 destructive, open-world mutation with no output schema and an undocumented parameter, yet the description provides no risk context, no prerequisite, and no notion of what state changes. Given the complexity profile, it is too thin.

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% for the single required parameter, and the description only embeds it in a URL template (DELETE /runners/{runner_id}/cache). It does not clarify whether runner_id refers to a global runner ID (versus a project runner) or where the ID can be obtained.

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+resource (clear global runner cache) and even names the underlying endpoint, so the operation is unambiguous. It doesn't explicitly distinguish itself from siblings like clear_project_runner_cache or clear_server_cache, but the resource name itself carries that 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?

There is no guidance on when to clear the cache versus the sibling clear_project_runner_cache or clear_server_cache, nor any precondition such as the runner needing to be idle or inactive. The agent must infer selection purely from the tool name.

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

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

Annotations already declare destructiveHint=true, idempotentHint=true, readOnlyHint=false, and openWorldHint=true, so the safety profile is covered. The description only echoes the HTTP method (DELETE) via the endpoint, adding no context about what is destroyed or the impact on in-flight tasks.

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

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

Two short fragments with no wasted words, and the action is front-loaded. It is efficient but so sparse that it borders on under-specification rather than tight conciseness.

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

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

This is a destructive mutation with no output schema and no annotations explaining consequences, yet the description offers only a name and endpoint. It omits what the cache is, whether the operation is reversible, and any guidance an agent needs before invoking a destructive call.

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 should compensate. It does show project_id as a path segment in the URL template, hinting it identifies the target project, but adds no format or constraint detail beyond that.

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 verb 'Clear' plus the endpoint path '/project/{project_id}/cache' do indicate that it clears a specific project's cache, which is more specific than the bare name. However, 'Clear Cache' restates the tool name and never states what cache or what the effect is, leaving scope 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 versus siblings like clear_server_cache, clear_global_runner_cache, or clear_project_runner_cache. The agent must infer selection purely from the tool name.

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

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

Annotations already declare destructive=true, idempotent=true, and openWorldHint=true, so the safety profile is covered. The description adds the underlying DELETE route, confirming the mutation scope is limited to a single runner's cache, but says nothing about what breaks (e.g., in-flight jobs or re-download requirements) or permission needs.

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, action first, endpoint second — no filler. It is appropriately sized for what little it chooses to convey.

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?

A destructive, no-output-schema mutation tool whose description gives no explanation of consequences, expected state after clearing, or failure modes. With 0% schema coverage and no output schema, the description leaves too much to 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?

Schema description coverage is 0%, so the description must compensate for two undocumented integer params. The path template shows both project_id and runner_id are scoping identifiers in the URL, but provides no format, range, or lookup guidance beyond that.

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 (Clear) and resource (project runner cache), which is unambiguous against most siblings. It does not explicitly distinguish itself from close siblings like clear_global_runner_cache or clear_project_cache, though the name and scoping imply the difference.

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 clear_project_cache or clear_global_runner_cache, nor any prerequisites or after-effects that would trigger it. The agent must infer usage entirely from 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?

Annotations already declare destructiveHint=true, idempotentHint=true, and openWorldHint=true. The description adds no behavioral context such as what specifically gets flushed, whether it affects running tasks, or how the operation is scoped. It only repeats the HTTP endpoint.

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

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

The description is very short, but the second sentence 'DELETE /cache.' is redundant with the tool name and annotations and does not clarify scope. It is concise but under-specified rather than efficiently 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 destructive cache-clearing operation in a family of similar cache tools, the description does not explain what 'server cache' means operationally or how it differs from project or runner caches. Annotations cover the safety profile, but the scope ambiguity remains a significant 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?

The tool takes zero parameters, so the baseline is 4. There are no parameter semantics to document, and the schema is fully explicit about the empty input.

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 'clear Cache. DELETE /cache.' largely restates the tool name rather than specifying what cache is cleared. It does not distinguish this server-level cache clearing from sibling tools like clear_project_cache, clear_global_runner_cache, or clear_project_runner_cache.

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 this tool should be used, what prerequisites exist, or which sibling cache-clearing alternative is appropriate. The agent is left to infer usage entirely from the tool name.

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

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

Annotations already declare destructiveHint=true, idempotentHint=false, and openWorldHint=true, so the safety profile is covered structurally. The description adds nothing on top of that: it does not say what state change occurs, whether the task must be awaiting confirmation, or whether the action 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?

It is short and front-loaded, but that brevity is under-specification rather than economy. The HTTP route line consumes space without conveying behavior an agent needs.

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 non-idempotent, destructive mutation with no output schema and zero parameter documentation, the definition is incomplete. An agent cannot tell from the description what confirming accomplishes or what happens to the task afterwards.

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 should compensate, but it only embeds the two IDs in a URL template. While the mapping of project_id and task_id to the path is mildly informative, no types, ranges, or meaning of 'confirm' relative to those IDs 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 restates the tool name ('Confirm Task') and appends an HTTP route. It signals that the operation targets a project-scoped task, but it does not say what 'confirming' a task actually does or how it differs from siblings such as reject_task, get_task, or stop_task.

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 confirm a task versus rejecting it (reject_task) or simply inspecting it (get_task, wait_for_task). No preconditions, state requirements, or exclusions are given.

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

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

Annotations already declare destructiveHint=true, idempotentHint=false and openWorldHint=true, so the safety profile is covered. The description adds the endpoint and a non-obvious serialization constraint (JSON-encoded string fields must stay strings), but says nothing about what the key grants, whether creation is reversible, or permission requirements.

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

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

Three short, front-loaded sentences with no filler. The terseness is appropriate, though the third sentence's phrasing ("JSON-encoded string fields must remain strings") is dense and could be clearer.

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 mutating tool that creates a credential, with a 14-property nested body, 0% schema description coverage, and no output schema. The description leaves out the polymorphic body requirements and permission prerequisites, which an agent needs to call it correctly.

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

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

Schema coverage is 0% and the description only says to put API fields in the body. It never explains the critical relationship between the `type` enum (none/ssh/login_password/string) and which corresponding sub-object must be populated, nor the meaning of `owner`, `override_secret`, or the source_storage_* fields.

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 ("Add access key") plus the underlying endpoint, so the operation is unambiguous. It does not differentiate from siblings like update_access_key, get_access_key, or list_access_keys, but the create semantics are clear.

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 update_access_key or the other key-related siblings, and no mention of prerequisites such as project permissions. The agent must infer the usage 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?

Annotations already declare destructiveHint=true, idempotentHint=false and openWorldHint=true, so the safety profile is covered. The description adds only the endpoint and a cryptic note about JSON-encoded string fields; it omits critical token-creation behavior such as whether the token value is returned once and never retrievable again, what permissions the token gets, and how expires_at defaults are handled.

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-loads the purpose and endpoint, which is good. The third sentence about JSON-encoded string fields is opaque and arguably does not earn its place without explaining which fields it refers to.

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 credential-minting, destructive-flagged operation with no output schema and an undocumented nested body, the description is too thin. An agent cannot tell from it what the response will contain (presumably the token) or how to safely handle the one-time secret.

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 body object with 'name' and 'expires_at'. The description only says 'Supply API fields in body', which merely restates the schema, and never explains name requirements/uniqueness or expires_at format and omission behavior. The trailing note about JSON-encoded string fields is confusing rather than clarifying.

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

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

The description states a specific verb and resource ('Create an API token') and even gives the HTTP endpoint, so the action is unambiguous. However, it does nothing to distinguish this from siblings like create_access_key or list_api_tokens/delete_api_token, which an agent must choose between.

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 such as create_access_key. The endpoint reference is not usage guidance.

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

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

Annotations already declare destructiveHint=true, idempotentHint=false, and openWorldHint=true, so the safety profile is covered. The description adds real value in the encoding caveat about JSON string fields and the endpoint, though it does not disclose what side effects occur (secret storage, sync initialization) or auth requirements.

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

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

Three short sentences with the action front-loaded and no filler. The endpoint is arguably redundant with the tool name but is harmless and useful for API-literate callers.

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, non-idempotent write with a large nested body, no schema descriptions, and no output schema, the description is too thin. An agent must guess which body fields exist and what the response will be.

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 body carries roughly a dozen fields, yet the description only says 'supply API fields in body' and warns that JSON-encoded string fields must remain strings. It never mentions name (the only required body field), project_id, secrets, or sync settings, so it does not compensate for the undocumented 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 and resource ('Add environment') plus the underlying endpoint POST /project/{project_id}/environment, so an agent knows exactly what resource is created. It does not differentiate from siblings such as update_environment or sync_environment, which keeps it below a 5.

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

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

There is no guidance on when to use this versus update_environment, sync_environment, or delete_environment, and no preconditions (project permissions, whether the environment must not already exist) are stated. 'Add' implies creation, but that inference comes from the name rather than the description.

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 the mutation and destructive/open-world profile, and the description adds edition/license gating, possible 404/empty-list responses, and the underlying POST /roles endpoint. It does not disclose required permission level, duplicate-slug behavior, or what happens on failure, which matters for a non-idempotent create.

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 operation and three compact sentences with no filler. 'Supply API fields in body' is slightly redundant with the schema 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?

For a create endpoint with a nested, undocumented body and no output schema, the description covers availability and transport-level behavior but omits the field-level semantics and permission requirements an agent needs to construct a valid call. It is minimally adequate rather than complete.

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

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

Schema description coverage is 0%, so the description carries the full burden, yet it only says to supply API fields in the body and keep JSON-encoded strings as strings. It never explains the required slug, name, permissions (apparently an integer bitmask), or optional project_id, leaving the nested body 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?

The description states a specific verb and resource ('create global role'), so an agent knows what operation it performs. It does not distinguish this from the sibling create_project_role or explain the global-vs-project scope difference, so sibling differentiation is missing.

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 gives useful availability context ('depends on Semaphore edition, license, and permissions') and warns that some Community routes return 404 or empty lists. However, it never says when to choose this over create_project_role or update_global_role, nor what prerequisites must be satisfied first.

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

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

Annotations already declare destructiveHint=true, openWorldHint=true, and idempotentHint=false, so the safety profile is covered externally. The description adds only the endpoint and a string-encoding caveat; it does not disclose side effects such as credential creation, default inactive/registered behavior, or required permissions.

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

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

The description is short, front-loaded with the action and endpoint, and contains no filler. The final string-encoding sentence is somewhat cryptic, but the overall structure is efficient.

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

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

For a destructive creation tool with a complex nested body and no output schema, the description is missing the details an agent needs: required body fields, default values, the registered-runner workflow, and how this differs from create_project_runner. The endpoint and body reference alone are not sufficient 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 description coverage is reported as 0%, so the description must compensate for a nested body with many fields. Instead it only says to 'Supply API fields in body' and warns that JSON-encoded string fields must remain strings, without naming fields, required values, defaults, or the meaning of 'registered' and 'project_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?

The description uses a specific verb and resource: 'Add global runner' with the endpoint POST /runners. It is distinguishable from create_project_runner by the 'global' resource name, though it does not explicitly explain when to choose this tool over the project-level sibling.

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 the sibling create_project_runner, no prerequisites, and no exclusions. The description only states what the tool does, leaving the agent to infer the global-versus-project decision 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?

Annotations already declare destructiveHint=true, idempotentHint=false and openWorldHint=true, so the safety profile is covered. The description adds one genuinely useful behavioral caveat ('JSON-encoded string fields must remain strings'), but it never explains what the destructive side effects are, that repeat calls create duplicates, or what comes back on success.

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

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

Three short sentences with the purpose front-loaded and no filler. The endpoint line is mildly redundant with the path parameter but still earns its place as a routing hint.

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

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

This is a non-idempotent, destructive create whose body schema is a large undocumented nested object with no output schema. The description covers only the surface; an agent still lacks required-body guidance, side-effect expectations, and any notion of what a successful creation returns.

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

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

Schema description coverage is 0% and the nested IntegrationRequest fields are entirely undocumented, so the description must compensate. It partly does, telling the agent to supply API field names in `body` and warning about string-encoded fields, but it never mentions the required `name` field, the `task_params` sub-structure, or that project_id also appears inside the body.

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 integration') and pins it to the POST /project/{project_id}/integrations endpoint, which is unambiguous about what object is being created. The verb alone separates it from update_integration/delete_integration, but no sibling is named or contrasted.

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 versus update_integration, create_integration_alias, or create_integration_value, and no prerequisites or permission notes. The only usage-adjacent information is the REST path, which the agent must infer conditions from.

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 flag this as destructive and non-idempotent, so the description should clarify what is being created or replaced, but it adds nothing. Critically, an alias creation presumably needs alias content, yet no payload or naming behavior is described, leaving the mutation opaque.

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

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

Only two short sentences and front-loaded with the verb, which is good. The second sentence is a redundant REST path restatement that adds little beyond what the schema already lists.

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?

Short and technically accurate for a two-parameter call, but for a destructive create tool with no output schema it leaves too much unsaid: what the alias consists of, what it affects, and what must exist beforehand. Adequate at best.

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 carry the burden, and it only restates project_id and integration_id as path segments via the URL template. It gives no meaning to what an alias is, no constraints, and the schema exposes no field for the alias value itself, which the description never addresses.

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 alias for an integration', with the target path spelled out. It does not, however, distinguish itself from the very similar siblings create_project_integration_alias and create_terraform_alias, so an agent cannot tell from the description alone which one applies.

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 the near-identical sibling create_project_integration_alias. The only orientation offered is a raw HTTP path, which does not help select the tool.

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 the operation as non-read-only, open-world, non-idempotent, and destructive, so the safety profile is largely covered. The description adds the endpoint and a useful note that JSON-encoded string fields must remain strings. However, it does not describe required permissions, side effects, or response behavior for a create operation.

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

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

The description is three short sentences and front-loads the action. The endpoint and body-encoding caveat are immediately visible. There is no wasted prose.

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 create tool with a nested body object, three required parameters, no output schema, and no parameter descriptions in the schema. The description provides the HTTP endpoint and one encoding warning but leaves out the body fields, enums, required nested values, and expected result. It is not complete enough for an agent to invoke confidently without opening the 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 0%, so the description must compensate but does not. It says to supply API fields in the body and warns about JSON-encoded strings, but it does not explain project_id, integration_id, or the nested fields key, name, value, method, match_type, and body_data_type. Agents must inspect the schema to understand most parameters.

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

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

The description clearly states a specific verb and resource: adding an Integration Matcher. The POST path reinforces that this creates a matcher under a project integration. It does not explicitly distinguish itself from sibling tools such as update_integration_matcher or create_integration_value.

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

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

The description gives no guidance on when to use this tool versus update_integration_matcher, create_integration_value, or list_integration_matchers. It also omits prerequisites such as whether the integration must already exist. Usage is only implied by the name and HTTP method.

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 disclose destructiveHint=true, idempotentHint=false, and openWorldHint=true, so the safety profile is largely covered. The description adds useful implementation context by naming the POST endpoint and warning that JSON-encoded string fields must remain strings, but it does not explain side effects, permissions, or behavior when the value 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?

The description is three short sentences, front-loads the action, then gives the endpoint and one concrete caveat. Every sentence contributes useful information with no filler.

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

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

This is a destructive, non-idempotent mutation tool with a nested body object whose fields are entirely undocumented in the schema. The description provides the endpoint and one field-format warning but leaves out required body-field semantics, expected effects, and any permissions or duplicate-handling 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 description coverage is 0%, so the description must compensate for undocumented parameters. It only identifies project_id and integration_id through the path and vaguely says to 'Supply API fields in body'; it does not explain body fields such as key, name, variable, value_source, variable_type, body_data_type, or their enums.

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: 'Add Integration Extracted Value', and reinforces it with the exact POST endpoint. It is distinguishable from sibling operations like update_integration_value, delete_integration_value, and get_integration_value by the create verb, though the phrasing is slightly awkward.

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

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

The word 'Add' implies creation, but the description gives no explicit guidance on when to use this tool versus update_integration_value or other integration-value tools. There are no prerequisites, exclusions, or alternative-routing instructions.

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 this as a non-readonly, non-idempotent, destructive, open-world mutation. The description adds the endpoint and a useful encoding constraint for JSON-encoded string fields. However, it does not explain permissions, side effects, or what creation affects beyond the project 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?

The description is short and front-loads the core action: create inventory. The endpoint and encoding note are relevant, though the phrasing is terse and could be slightly more organized.

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, non-idempotent create operation with a nested request body and no output schema, the description is too thin. It omits permissions, side effects, error behavior, and most body-field semantics, leaving the agent under-informed about a complex mutation.

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 body contains a complex InventoryRequest with fields such as name, type, inventory, runner_tag, ssh_key_id, and template_id. The description only says to supply API fields in the body and keep JSON-encoded strings as strings; it does not clarify required fields, enums, nullable IDs, or project_id/body interaction enough to compensate.

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

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

The description states a clear verb and resource: create an inventory. It also identifies the HTTP path, showing that creation is project-scoped. It does not explicitly distinguish this from update_inventory, delete_inventory, or other create_* tools, but the purpose is still easy to infer.

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

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

There is no explicit guidance on when to use this tool versus update_inventory, list_inventories, or attach_template_inventory. The POST endpoint implies creation, but the description gives no prerequisites, when-not-to-use cases, or alternative routing.

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 this as a non-read-only, non-idempotent, destructive, open-world operation. The description adds the HTTP endpoint and a body-format constraint about JSON-encoded string fields, but does not explain permissions, side effects, or what project resources are created. There is no contradiction with the annotations.

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

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

The description is short and front-loaded with the action and endpoint. The sentence about body fields and JSON-encoded strings is useful, though slightly cryptic. There is little wasted text.

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

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

The definition covers the basic call shape and the annotations already describe the mutation safety profile. However, for a project-creation tool with a nested request body and no output schema, the description omits field semantics, side effects, and usage boundaries. It is minimally adequate but not rich.

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 says to supply API fields in the body and that JSON-encoded string fields must remain strings. It does not explain the required name field, the demo/alert/type fields, or their meaning. The body-format note adds some value, but most parameter semantics are left 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?

The description states a specific verb and resource: "Create a new project." It also names the endpoint POST /projects, which makes the operation clear. It does not explicitly distinguish itself from related siblings like update_project or delete_project, but the create 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?

The description implies use when a new project is needed, but gives no explicit when-to-use guidance, prerequisites, or alternatives. It does not say when to prefer create_project over update_project, list_projects, or other project-related 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?

The annotations already declare destructiveHint=true, idempotentHint=false, and openWorldHint=true, which communicates the risk profile. The description adds only the POST endpoint, without explaining what an alias is, what side effects occur, what permissions are required, or whether existing aliases 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 two short sentences with no wasted words, and the core action is front-loaded. The endpoint path adds minor operational context without making it 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?

This is a destructive create operation with no output schema and an undocumented parameter. The description should explain what an integration alias represents, what happens after creation, and how it relates to project integrations. None of that is present.

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 one parameter (project_id) with 0% description coverage, so the description must compensate. It only implies project scoping via 'for the project' and the endpoint path, without explaining format, constraints, or expected value beyond the schema's integer type.

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: 'Create a new integration alias for the project.' It clearly identifies the project-scoped nature of the operation. However, it does not distinguish itself from the sibling tool create_integration_alias, so an agent must infer the difference from context alone.

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 create_integration_alias, list_project_integration_aliases, or other project-integration tools. It also omits prerequisites or conditions for creating an alias.

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 destructiveHint=true, idempotentHint=false, and openWorldHint=true, so the safety profile is covered. The description adds value beyond that with edition/license gating and the 404/empty-list caveat on Community routes, plus the instruction that JSON-encoded string fields must remain strings. It still doesn't state exactly what gets created or whether retries are safe.

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

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

Three short sentences, front-loaded with the action and immediately followed by the eligibility caveat and endpoint. No filler, though the endpoint string adds little beyond what a client already knows and the body hint is compressed to the point of ambiguity.

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 output schema and a nested body at 0% schema coverage, the description covers availability and endpoint but leaves the body contract underspecified. An agent knows it may 404 on Community but not what a valid permissions value or slug format looks like.

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 carries the full burden for two required parameters, including a nested body with slug, name, permissions, and a redundant project_id. It only says 'Supply API fields in body; JSON-encoded string fields must remain strings,' which says nothing about what slug vs name mean or what the integer permissions value encodes.

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

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

The description opens with a specific verb+resource ('create project role') and names the endpoint POST /project/{project_id}/roles, so an agent can distinguish it from update_project_role, delete_project_role, and list_project_roles. It stops short of explicitly naming siblings, but the CRUD prefix makes the distinction self-evident.

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 adds real eligibility context ('Availability depends on Semaphore edition, license, and permissions; some Community routes return 404 or empty lists'), which helps the agent decide whether calling is even viable. However, it never states when to prefer this over update_project_role or create_global_role, and gives no prerequisite/ordering 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 destructiveHint=true, openWorldHint=true and idempotentHint=false, so the safety profile is covered. The description adds the endpoint and a serialization caveat ('JSON-encoded string fields must remain strings'), which is genuine extra context, but says nothing about the fact that a runner created this way may need a registration token before it can work.

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

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

Three short sentences, action and endpoint front-loaded, no filler. It is tight, but its brevity comes partly from omitting things that matter rather than from efficient encoding.

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 mutating creation tool with no output schema and an unannotated nested body, the description should say what comes back (e.g. the runner object or a token) and what happens when registered=false. Neither is present, so an agent cannot predict the result of the call it is about to make.

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 reported as 0%, so the description is the only place an agent could learn parameter meaning — yet 'Supply API fields in body' adds nothing. It never names name, tags, active, webhook, is_default, or max_parallel_tasks, and the 'JSON-encoded string fields' hint is not tied to any identifiable field (webhook is the only string, and it isn't called out).

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 ('Add project runner') and pins it to an HTTP endpoint (POST /project/{project_id}/runners), so the agent knows this creates a project-scoped runner. It does not explicitly contrast with create_global_runner, which is the one adjacent call an agent could plausibly confuse it with.

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 (project admin rights), and no alternatives named. The key decision an agent faces — create_project_runner vs create_global_runner, and set registered=false plus a registration-token flow — is nowhere acknowledged.

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 destructiveHint=true and idempotentHint=false, which is non-obvious for a "link" operation, yet the description says nothing about what gets destroyed, whether re-adding an existing member errors, or what permissions are needed. The one behavioural note (JSON-encoded string fields must remain strings) is obscure and doesn't map to any visible parameter.

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 with the core action, which is good. However, the third sentence about JSON-encoded string fields is cryptic in a schema whose only string field is a free-form role, so that sentence does not clearly 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 destructive, non-idempotent, open-world mutation with a nested body object and no output schema, the description omits membership semantics, role validity, error behaviour, and prerequisites. An agent could parse it but would likely call it with an incorrect or underspecified body.

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 description does not name the nested body fields role or user_id, nor explain valid role values or how they are obtained. The vague instruction to "supply API fields in body" leaves the agent to guess the required body shape from the raw 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?

"Link user to project" states a specific verb and resource, and separates it from update_project_user and delete_project_user. The added endpoint reference (POST /project/{project_id}/users) reinforces the create semantics, but it never names the sibling tools it should be chosen over.

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 update_project_user (existing membership) or create_user (user does not exist yet). The only instruction is a mechanical note about supplying body fields, which is invocation mechanics rather than 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?

Annotations already declare the safety profile (destructiveHint=true, idempotentHint=false, openWorldHint=true), so the bar is lower. The description still adds genuine value with the serialization caveat that JSON-encoded string fields must remain strings, a real failure mode for agents. It stops short of stating required permissions, what happens to the request on validation failure, or what is returned.

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

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

Three short, front-loaded fragments: verb first, then endpoint, then the encoding constraint. Zero filler, though the telegraphic style leaves some ambiguity about how the 'API fields' passthrough relates to the nested 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 mutating open-world creation tool with two required parameters, a six-property nested object, no field descriptions and no output schema, the description is thin. An agent cannot learn from it which fields are mandatory nor what a successful call returns, so it must reverse-engineer the schema by trial.

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 carry the load, and it largely does not: it never names the required body fields (name, git_url) nor explains the optional ones (git_branch, ssh_key_id, id). What it does add is the useful framing that body is a passthrough of API fields and the encoding caveat, but no field-level meaning.

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?

"Add repository" gives a specific verb plus resource, reinforced by the concrete endpoint POST /project/{project_id}/repositories. It is clearly distinguishable from siblings such as update_repository, delete_repository and list_repositories, though it never names them explicitly.

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

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

There is no statement of when to use creation versus update_repository, no mention of prerequisites (project membership, permissions, whether a project must exist first), and no exclusions. The only guidance is mechanical ('supply API fields in body'), which is not usage selection.

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 destructiveHint=true, openWorldHint=true and idempotentHint=false; the description adds only a note about body field encoding. It never warns that creating a schedule may trigger automated jobs, that schedules are persistent/destructive state, or what happens on duplicate creation.

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 route and the key encoding caveat; only the redundant opening fragment 'create schedule' wastes space.

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 create tool with a 0%-documented nested body, no output schema and no annotations explanation of consequences, this is far too thin; an agent could not safely construct a valid schedule body from this definition alone.

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

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

Schema description coverage is 0% and the body is a large nested object, yet the description only says to 'supply API fields in body' and that JSON-encoded strings stay strings. It explains nothing about the schedule 'type' enum, cron_format vs run_at, task_params, or which of project_id/template_id/repository_id drive behavior.

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 the verb and resource ('create schedule') plus the route 'POST /project/{project_id}/schedules', so an agent can tell it makes a new schedule under a project. However, it does not differentiate from nearby siblings such as create_task, create_template or validate_schedule, and the first sentence merely restates 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?

No guidance on when to use this versus validate_schedule, list_schedules or update_schedule, and no prerequisites (e.g. whether a template_id or repository_id is mandatory). The agent must infer usage entirely from the 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 destructiveHint=true, idempotentHint=false, and openWorldHint=true, so the safety profile is largely covered. The description adds no real behavioral context: it doesn't say how the secret is stored/validated, what happens on duplicate names, or that a secret credential is being persisted.

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 plus an endpoint, so it is compact and front-loaded. But "Add." is a wasted fragment and the brevity comes at the cost of under-specification rather than information density.

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 create tool with a complex nested body, zero schema coverage, and no output schema, the description leaves an agent unable to construct a correct body without the raw schema. It should at minimum outline the required body fields and the type enum.

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% on a nested body with ~10 properties (type enum, params, secret, sync_paths, sync_interval), so the description is responsible for compensation. It offers only "supply API fields in body" and a note that JSON-encoded strings stay strings – no field meanings, no required-field guidance, no enum context.

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

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

The description opens with the vague verb "Add" and never names the resource in prose; the resource is only inferable from the endpoint path `/project/{project_id}/secret_storages`. The tool name carries most of the meaning, and nothing distinguishes this from update_secret_storage or create_integration.

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, no mention of the sibling update_secret_storage/delete_secret_storage alternatives. The only instruction is a formatting note about the body, which is not usage guidance.

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

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

Annotations already flag destructive=true, idempotent=false and openWorld=true, and the description adds real context beyond them: 'This executes code on managed infrastructure' warns of consequential side effects, and the emphasis that JSON-encoded strings must stay strings heads off a common serialization failure. It does not cover permissions or concurrency 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?

Purpose is front-loaded, followed by parameter placement rules, a safety warning, and the endpoint. It is compact and mostly waste-free, though 'environment and arguments are JSON-encoded strings' and 'JSON-encoded string fields must remain strings' partially restate each other.

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

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

Given a nested body with ~14 properties at 0% schema coverage, a destructive annotation, and no output schema, the description covers the highest-risk traps but leaves most body fields (secret, message, playbook, version, inventory_id, build_task_id) entirely undocumented. Adequate but with clear gaps for a mutation tool of this 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?

Schema description coverage is 0% on a deeply nested body, but the description supplies genuinely useful placement rules: Ansible/Terraform switches go under body.params, environment and arguments are JSON-encoded strings. It still says nothing about template_id being the sole required body field or what limit, secret, playbook, inventory_id or version mean.

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 concrete verb+resource ('Start an automation task') and even gives the underlying REST route (POST /project/{project_id}/tasks), so the operation is unambiguous. It does not, however, distinguish this from nearby siblings such as run_workflow or create_schedule, leaving that differentiation to the name alone.

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 versus run_workflow or wait_for_task, no prerequisites (e.g., a template must exist and template_id is required), and no exclusions. Usage is only implied by the word 'Start'.

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 declare destructiveHint=true, readOnlyHint=false, openWorldHint=true, and idempotentHint=false, so the safety profile is covered. The description adds the POST endpoint and a useful note that JSON-encoded string fields must remain strings, but it does not elaborate on destructive side effects, auth needs, or idempotency beyond the annotations.

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

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

The description is short, front-loaded, and has no wasted sentences. The endpoint and string-field constraint are useful, though the overall terseness leaves important gaps for a complex create operation.

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

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

This is a destructive create operation with a large nested body, no output schema, and 0% schema description coverage. The description does not explain required fields, conditional requirements, or body structure, so it is not complete enough for an agent to safely construct the request without relying entirely on schema inspection.

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 for undocumented parameters. It only says to supply API fields in the body and that JSON-encoded string fields must remain strings; it does not explain project_id, the required name field, app-specific conditionals (inventory_id vs. playbook), or nested body structure.

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

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

The description states a specific verb and resource ('create template') and includes the endpoint, so the agent can tell it creates a template. It does not explicitly differentiate itself from siblings such as update_template or delete_template, but create vs. update/delete is reasonably clear.

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

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

The description gives no guidance on when to use this tool versus alternatives, prerequisites, or when not to use it. It only states the endpoint and a body-format note, leaving usage selection to inference.

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

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

Annotations already declare readOnly=false, destructive=true, openWorld=true, and idempotent=false, so the safety profile is covered. The description adds the POST endpoint and a body-encoding caveat, but does not explain the access-control impact, required authorization, or non-idempotent effects of adding a permission.

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 action and endpoint. The abbreviation 'Perm' slightly reduces clarity, but there is little 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 destructive mutation with a nested body object, three required parameters, 0% schema description coverage, and no output schema, the description is incomplete. It omits body field semantics, access implications, and expected response behavior.

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

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

Schema description coverage is 0%, so the description must compensate for undocumented parameters, but it only says 'Supply API fields in body' and notes JSON-encoded string fields must remain strings. It does not explain required fields such as role_slug and permissions, or what the permissions integer represents.

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: 'Add Template Perm' plus the POST endpoint for template permissions. It is understandable despite the abbreviation 'Perm', and it distinguishes creation from sibling list/get/delete/update tools, though it does not explicitly contrast with update_template_permission.

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 gives no guidance on when to use this tool versus update_template_permission, delete_template_permission, or list_template_permissions. The only usage information is the HTTP endpoint and a body-format caveat, leaving the agent to infer intent.

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 the write/safety profile, and the description adds genuinely non-obvious context: edition/license/permission gating, that some Community routes silently return 404 or empty lists, and that JSON-encoded string fields must stay strings. That is real behavioral value beyond the annotations, though it says nothing about the effect of creation or what a successful response looks like.

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, but telegraphic fragments ('create terraform alias.', 'Supply API fields in body') and a raw endpoint path that partly duplicates the schema. Efficient in size, weak in readability.

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 zero schema coverage, the description is the only documentation, and it omits the required body field, the meaning of each body property, and the result of the call. The availability caveat is useful but insufficient for a mutation tool with a nested required body.

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% across 3 parameters (including a nested body with four properties), so the description must carry the load. It only implies project_id/inventory_id via the URL template and waves at the body generically; the required auth_key_id and the optional alias/project_id/inventory_id body fields are never mentioned.

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 the verb and resource ('create terraform alias') and gives the concrete endpoint path, so the resource is identifiable. But it never explains what a terraform alias actually is (a mapping between a Terraform state and an auth key/inventory), so an agent unfamiliar with the domain gets only a name restatement plus a URL.

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 update_terraform_alias, delete_terraform_alias, or list_terraform_aliases, and no prerequisites beyond a vague 'depends on edition, license, and permissions'. The 404/empty-list note describes route availability, not usage selection.

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 disclose destructiveHint=true, idempotentHint=false, and openWorldHint=true, so the safety profile is covered. The description adds the API endpoint and a field-format constraint, but does not mention required permissions, duplicate-user behavior, or what happens on failure. It does not contradict 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 three short sentences and front-loads the key action and endpoint. Every sentence contributes useful information without repetition or filler.

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

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

For a destructive user-creation mutation with no output schema and zero schema description coverage, the description is too thin. It omits permissions, validation expectations, duplicate handling, response behavior, and the meaning of the nested body fields.

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 body parameter contains seven nested fields with no individual descriptions. The description only says to supply API fields in the body and that JSON-encoded string fields must remain strings; it does not explain field meanings, required combinations, or password handling.

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: 'Creates a user.' It is clearly distinct from update_user and delete_user by name and action. However, it does not explicitly differentiate itself from siblings beyond the obvious create operation.

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 create_user versus update_user, list_users, or get_user. It simply states that it creates a user and the HTTP endpoint, leaving selection between sibling tools 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 already declare this as a non-readonly, destructive, open-world, non-idempotent operation. The description adds useful context via the POST endpoint and the note that JSON-encoded string fields must remain strings, but it does not explain permissions, side effects, or what exactly is created.

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 action and endpoint. The body-format note is relevant, though the fragmentary style and minimal repetition of the tool name keep it from being maximally polished.

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 create operation with a nested body schema and no output schema, the description gives the endpoint and a body encoding hint. It remains thin on body-field semantics and permissions, but annotations cover the safety profile and the schema exposes the basic field names and types.

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 mentions project_id implicitly through the path and says to supply 'API fields in body.' It does not document the body fields (title, position, id, project_id) or their required/optional status, aside from a narrow JSON-string note.

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

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

The description states a specific verb and resource ('create view') and adds the exact POST endpoint, so the agent can identify the operation. It does not explicitly differentiate from siblings such as update_view or delete_view, but the verb makes the intended action clear.

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 gives no guidance on when to create a view versus update_view, delete_view, or set_view_positions. There are no prerequisites or exclusions, only the endpoint and a body-format note.

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 destructiveHint=true, non-idempotent and open-world, and the description adds beyond them: edition/license gating and 404/empty-list failure modes. It does not reconcile the destructive flag with a pure 'add' operation (e.g. what gets overwritten, whether duplicate names collide) or explain the non-idempotent behavior on retry.

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

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

Five short sentences, front-loaded with the action and endpoint, with no filler. Slightly telegraphic ('Add workflow.'), but every sentence carries 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 mutation tool with a deeply nested, undescribed body (WorkflowNode, WorkflowEdge, TaskPrams), no output schema, and destructive annotations, the description should at least sketch the node/edge model and required body fields. Instead it leaves the agent to infer the entire payload shape from a parameterless 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 coverage is 0% and the body is a nested WorkflowTemplate with nodes/edges, so the description carries the load; 'supply API fields in body; JSON-encoded string fields must remain strings' is genuinely useful wiring guidance. But it says nothing about project_id, the nodes/edges structure, or which template fields are required, so it only partially compensates.

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 the resource (workflow) and the endpoint POST /project/{project_id}/workflows, but the verb 'Add' is close to restating the tool name and it never says what a workflow is (a node/edge graph) or how it differs from neighboring create_* tools like create_template or create_task.

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 gives real preconditions — availability varies by Semaphore edition, license and permissions, and Community routes may 404 or return empty lists — which is useful when-to-use context. However, it never says when to choose create_workflow over create_template/create_task or what to do when the route 404s.

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 destructiveHint=true, idempotentHint=true and readOnlyHint=false, so safety profile is covered. The description adds only the route, revealing that keys are project-scoped, but says nothing about whether deletion is permanent, whether access is revoked immediately, or what happens to anything referencing the key.

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 action and followed by the route. Nothing is wasted, though the brevity borders on under-specification for a destructive operation.

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

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

For a destructive, open-world mutation with no output schema and entirely undocumented parameters, the description is missing consequences, authorization expectations, and any confirmation semantics. An agent has enough to fire the call but not enough to be confident about side effects.

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

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

Schema coverage is 0% and neither parameter is described. The route template conveys that key_id is nested under project_id, which is a small but real gain; otherwise the meaning of the two required integer IDs is left entirely to the schema's type/minimum constraints.

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 ('Removes access key') and pins the exact REST route, so its scope (a key inside a project) is unambiguous. The verb also implicitly distinguishes it from the create/update/get/list access key siblings, though none are named.

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

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

No guidance on when to use this versus update_access_key, create_access_key, or whether deletion is the right remedy for a compromised key. There are no prerequisites, warnings, 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?

Annotations already declare destructiveHint=true, idempotentHint=true, and openWorldHint=true, so the safety profile is covered structurally. The description adds nothing beyond the HTTP endpoint — it doesn't say the token stops authenticating immediately, whether the action can be undone, or how errors are surfaced.

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 action; nothing is padded. Terseness here is close to under-specification but the structure itself is sound.

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, irreversible credential-removal tool with no output schema and an undocumented parameter, the description leaves out the sourcing of token_id and the consequence of the call — an agent has to infer both.

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 place token_id could be explained. It only echoes the path template; it doesn't say the id comes from list_api_tokens or what format it takes.

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?

'Expires API token' states a specific verb and resource, and the DELETE /user/tokens/{token_id} path removes ambiguity about what object is affected. It distinguishes adequately from siblings like delete_access_key and create_api_token without needing to name 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?

No guidance on when to use this versus alternatives (e.g. revoking via update, or delete_access_key for other credential types), and no mention of prerequisites or irreversibility in the description text itself.

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 destructiveHint=true, idempotentHint=true, and readOnlyHint=false, so the safety profile is covered structurally. The description adds nothing beyond that — no mention of cascade effects (e.g., whether related records are removed), permission requirements, or irreversibility confirmation, which is the kind of context a deletion tool should supply.

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 fragments with no waste, and the action is front-loaded. It is arguably too sparse rather than too long — the restated endpoint contributes little value relative to the missing context.

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?

Annotations cover the destructive/idempotent profile and the schema is trivial, but among dozens of delete_* siblings and multiple app-related mutations, the description gives no basis for correct selection. For a destructive operation, the definition is thinner than it should be.

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

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

With a single self-evident parameter (app_id) and 0% schema description coverage, the endpoint path /apps/{app_id} does confirm the parameter is the app identifier. No format, type, or lookup guidance is added, but little is needed for one obvious ID field.

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 ("delete App") and confirms the REST endpoint behind it, so the basic action is unambiguous. However, it largely restates the tool name and does not explain what an "App" is or how this differs from sibling operations on the same resource (update_app, set_app_active, get_app).

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 delete an app versus deactivating it via set_app_active or modifying it via update_app, and no preconditions or warnings. The agent must infer everything from the tool name.

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

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

Annotations already declare destructiveHint=true, idempotentHint=true, and openWorldHint=true, so the safety profile is covered structurally. The description adds nothing beyond the name and endpoint path — no mention of what happens to dependent resources (references, templates bound to the environment) or whether deletion is permanent.

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, front-loaded sentences with no filler. It is efficient, though the second sentence (REST path) is essentially a restatement of transport rather than added 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?

For a destructive, non-reversible-by-design operation with zero parameter documentation and no output schema, the description is too thin. It leaves out cascade behavior, prerequisites, and confirmation expectations an agent needs before invoking a delete.

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 carries the burden, yet it only embeds the two parameters in a URL template. It adds no meaning about what project_id vs environment_id identify, nor validation or scoping constraints beyond type/minimum 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?

States a specific verb ('Removes') and resource ('environment'), which is unambiguous about the operation. It does not differentiate from siblings such as delete_project or update_environment, but the core purpose is clear without opening the schema.

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 alternatives (update_environment, delete_project, or the get_environment_references tool that could inform deletion safety). The agent must infer usage entirely from 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?

Annotations already declare destructiveHint=true, idempotentHint=true and openWorldHint=true, so the safety profile is covered. The description adds genuinely new behavior — edition/license/permission dependence and that some Community routes return 404 or empty lists — which helps an agent interpret failures. It stops short of saying whether deletion is permanent, what happens to users holding the role, or what a success response looks like.

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 action, with no padding. Slight waste in the opening lowercase restatement of the tool name, but overall tight and readable.

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 output schema and no parameter documentation, the description leaves key gaps: irreversibility, side effects on role assignments, and how to source the role_slug. The edition-availability caveat is a good start but insufficient for a delete operation.

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

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

Schema description coverage is 0% for the single required role_slug property, so the description must compensate. Beyond the endpoint template implying it is a path segment, it never explains whether the value is a slug or numeric id, its format, or that list_global_roles is the way to obtain 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?

States a specific verb+resource ("delete global role") and pins it to the endpoint DELETE /roles/{role_slug}, which distinguishes it from the many other delete_* siblings. It does not explicitly contrast with delete_project_role or update_global_role, but the name plus endpoint make the target 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 guidance on when to use this versus alternatives (e.g. delete_project_role, update_global_role) or what prerequisites exist before deletion. The availability note about edition/license/permissions and 404s is environmental context, not usage routing, so an agent still has to infer when this call 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 declare destructiveHint=true, idempotentHint=true, and openWorldHint=true, so the safety profile is covered structurally. The description adds nothing beyond the REST path — no statement about irreversibility, whether the runner must be unattached from projects, or what happens to jobs assigned to it.

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-loads the operation, which is good. However, the second sentence merely restates the HTTP endpoint and carries no decision-relevant information for an agent.

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 output schema and an undocumented parameter, the description should cover preconditions and consequences. It leaves the agent without guidance on side effects, dependent resources, or confirmation requirements.

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 single runner_id parameter is documented only as an integer with minimum 1. The description does not explain where to obtain that ID (e.g., via list_global_runners) or what it identifies.

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

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

The description names a specific verb and resource ("Delete global runner"), which is clear enough for an agent to identify the operation. The word "global" implicitly separates it from the many project-scoped siblings such as delete_project_runner, but the description never makes that distinction explicit.

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 delete_project_runner, update_global_runner, or set_global_runner_active. No prerequisites or warnings about what conditions must hold before a runner can be deleted 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?

Annotations already declare destructiveHint=true, idempotentHint=true, and openWorldHint=true, so the safety profile is covered structurally. The description adds the admin-only permission requirement, but does not clarify the ambiguity it introduces (does it stop a running task, or delete a queued one) or what happens to task output.

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

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

Two compact clauses with the core action and the admin constraint front-loaded; no filler. The 'Stop or remove' hedge is the only thing that could be tightened.

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-param destructive delete with annotations covering safety, the definition is nearly sufficient. The remaining gap is the unresolvable stop-vs-delete ambiguity and the undocumented task_id, which an agent cannot fill from the 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?

Only one parameter, but schema description coverage is 0% and the description gives no detail beyond the DELETE /tasks/{task_id} path, which merely implies task_id is a task identifier. It doesn't state whether task_id refers to a global-scope task specifically.

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 concrete verb+resource ('Stop or remove a task') scoped to the 'global running/queued task pool' and gives the endpoint. The 'global' qualifier distinguishes it from the sibling delete_task, though the dual 'stop or remove' framing slightly blurs exactly what happens.

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?

'(administrator only)' is a useful precondition, but the description never says when to pick this over delete_task, stop_task, reject_task, or clear_cluster_tasks. Usage must be inferred from the word 'global' and the running/queued phrase.

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 destructiveHint=true, idempotentHint=true and openWorldHint=true, so the safety profile is covered structurally. The description adds little beyond restating the operation and path — it does not say what happens to dependent aliases/values/matchers or whether the removal is reversible, which is the context an agent would actually need here.

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 fragments, front-loaded with the action and followed by the endpoint. No filler, though the endpoint restates the operation rather than adding new information, making the second sentence low-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?

For a two-parameter destructive delete with no output schema, the annotations cover the safety signal, but the 0% parameter coverage and the absence of any cascade/attachment behavior leaves an agent without enough to call it confidently in ambiguous cases.

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

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

Schema description coverage is 0%, so the description must carry parameter meaning; the URL template does show that project_id and integration_id are path identifiers scoping the target resource. However, it adds nothing about identifier provenance (where to obtain an integration_id) or precedence, so compensation is only partial.

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 ("Remove integration") and the REST path confirms it targets a project-scoped integration. It is not explicitly differentiated from the many sibling delete tools (delete_integration_value, delete_integration_alias, delete_integration_matcher), so the agent must infer that this removes the integration itself rather than a sub-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 when-to-use or when-not-to-use guidance, and no mention of the closely related siblings (delete_integration_value, delete_integration_alias, delete_integration_matcher) or of any prerequisite such as detaching the integration first. The usage is only implied by the tool name.

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

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

Annotations already declare destructiveHint=true, idempotentHint=true, and openWorldHint=true, so the safety profile is covered. The description adds only the REST endpoint path and does not clarify what happens to flows referencing the alias after deletion, which would be genuinely useful for a destructive operation.

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

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

Two short sentences with the action front-loaded and zero wasted wording. Nothing could be removed without losing information.

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

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

For a destructive mutation with three undocumented parameters and no output schema, the description is thin. It omits what state is changed, whether cascading effects occur, and how the project-scoped variant differs, leaving key gaps.

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

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

Schema description coverage is 0%, so the description must compensate. It partially does by exposing the path template, which shows alias_id is nested under integration_id and project_id, giving useful hierarchical meaning beyond bare integer types, but no format or constraint 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?

States a specific verb ('Remove') and resource ('integration alias'), making the operation unambiguous. However, it does not differentiate from the near-identical sibling delete_project_integration_alias, so an agent cannot tell which to pick from the description alone.

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 vs delete_project_integration_alias, delete_integration, or delete_integration_value. No prerequisites such as required permissions or whether the alias must be unused 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?

Annotations already declare destructiveHint=true, idempotentHint=true, and openWorldHint=true, so "Removes" restates the structured hint. The description adds nothing beyond the annotations: no cascade behavior, no permission/scope requirements, no mention of what breaks if the matcher is referenced elsewhere.

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

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

Two short sentences with the action front-loaded and zero filler. It is efficient but terse to the point of under-specification, which the conciseness dimension does not penalize but keeps it from a 5.

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, open-world mutation with no output schema and no parameter documentation, the description should carry more: irreversibility, referential-integrity risks, and ID sourcing. Only the endpoint path is supplied.

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 all three parameters are bare integers with only a minimum. The URL template implies the nesting (matcher inside integration inside project), which is mild added value, but there is no guidance on where to obtain the IDs or what happens on a mismatched hierarchy.

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 ("Removes integration matcher") and even gives the REST endpoint, so the operation is unambiguous. It does not, however, distinguish itself from adjacent siblings such as delete_integration, delete_integration_alias, or update_integration_matcher.

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-to-use, or prerequisite guidance. The agent must infer from the name alone that this deletes a single matcher and that get_integration_matcher_references might be worth checking first.

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

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

Annotations already declare destructiveHint=true, idempotentHint=true and openWorldHint=true, so the safety profile is largely covered. The description adds essentially nothing beyond restating deletion — no mention of whether dependent data is removed, whether the deletion cascades, or whether errors occur when references 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 short, front-loaded sentences with no filler. The endpoint path is compact and informative rather than filler, though it takes space that could have carried behavioral 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?

For a destructive, no-output-schema mutation with three fully undocumented parameters, the description is too thin: it omits preconditions, side effects on references, and error behavior. Annotations carry the safety signal, but the operational 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% for all three required integer parameters, so the description should compensate. The URL template does convey the hierarchy (value_id scoped under integration_id under project_id), which is some help, but no parameter is explained in words or given format/constraint guidance beyond 'minimum: 1' 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?

States a specific verb ('Removes') and resource ('integration extract value'), and the endpoint path confirms it operates on a single value nested under a project/integration. It is distinguishable from delete_integration, delete_integration_alias and delete_integration_matcher by the 'value' noun, though it never names those siblings.

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

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

No guidance on when to use this rather than deleting the whole integration or an alias/matcher, no preconditions, and no note about consequences for anything referencing the value. Usage is only implied by the resource 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?

Annotations already declare destructiveHint=true, idempotentHint=true, openWorldHint=true, and readOnlyHint=false, and the description is consistent with that. However, the description adds no behavioral detail beyond the annotations, such as what related data is affected, whether deletion is reversible, or whether prerequisites exist.

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

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

The description is two short sentences with no filler, and the core action is front-loaded. The endpoint adds compact context without bloating 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?

For a destructive operation with no output schema, the description should clarify effects and prerequisites, but it only restates removal and the endpoint. The annotations carry safety hints, yet important context about what gets removed and what must be true before deletion 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 carry parameter meaning, but it only shows project_id and inventory_id as path placeholders. It does not explain their format, constraints, or semantics beyond the schema's type definitions.

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: "Removes inventory," and gives the endpoint path. It is clear what the tool does, though it does not explicitly distinguish itself from nearby operations such as detach_template_inventory or delete_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?

There is no guidance on when to use this deletion operation versus alternatives, nor are there preconditions or exclusions. The agent must infer usage entirely from the tool name and endpoint.

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 destructiveHint=true, idempotentHint=true, openWorldHint=true, and readOnlyHint=false. The description adds only the HTTP method and path; it says nothing about what gets destroyed, whether deletion cascades to related resources, required permissions, or confirmation needs.

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 terse, front-loaded fragments with no filler or repetition. Its brevity is structurally clean, though for a destructive operation it borders on under-specification.

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 project deletion with no output schema, the description lacks irreversibility warnings, cascade or related-resource impact, permission requirements, and the restore_project alternative. The annotations cover safety flags but not the operational context an agent needs before invoking this tool.

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

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

Schema description coverage is 0% for the single required project_id integer. The description only shows project_id in the path template; it does not explain whether this is a numeric project ID, where to obtain it, or how it relates to project names.

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 project' plus the endpoint 'DELETE /project/{project_id}' confirms the exact operation. It does not distinguish itself from restore_project or the many sibling delete tools, so it falls short of a 5.

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

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

Provides no when-to-use guidance, no warning that deletion is irreversible, and no mention of the restore_project alternative. The agent must infer usage entirely from the tool name.

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

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

Annotations already declare destructiveHint=true, idempotentHint=true and openWorldHint=true, so the safety profile is covered. The description adds only the REST endpoint, saying nothing about what is lost, whether attached integration values/matchers are affected, or required permissions — acceptable given annotations, but 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?

Two short sentences, action front-loaded before the endpoint detail. No filler, though the endpoint restates what the parameter names roughly imply.

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?

A destructive, project-scoped delete with no output schema and undescribed parameters; annotations cover reversibility/safety, but the description leaves unresolved what an agent needs to know about authorization and side effects beyond 'this deletes the alias'.

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% for two integer params, so the description must compensate. The path template does imply alias_id is scoped under project_id, which is useful, but gives no constraints, formats, or error behavior for either.

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 ('Remove') and resource ('integration alias'), and the endpoint path clarifies it is the project-scoped alias rather than the global one. It is distinguishable from delete_integration_alias and create_project_integration_alias, though the description never explicitly contrasts 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?

No guidance on when to use this versus delete_integration_alias, list_project_integration_aliases, or update_integration. No prerequisites or exclusions (e.g. whether the alias must be unreferenced first).

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

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

Annotations already declare destructiveHint=true and idempotentHint=true, so the safety profile is covered. The description adds useful behavioral context about edition/license/permission dependence and Community-edition 404 or empty-list behavior, which is 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?

Three short sentences, front-loaded with the action and endpoint. The availability caveat is useful, though the description is terse and could better organize the parameter or error details.

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, open-world delete operation with no output schema, the description covers availability and some error behavior. It still omits important context such as what exactly is removed, cascading effects, and permission requirements beyond a general mention.

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 for parameter meaning. It only restates project_id and role_slug as path parameters in the DELETE route, without explaining formats, constraints, or how role_slug should be obtained.

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 project role.' It is clearly a deletion operation, though it does not explicitly distinguish itself from sibling tools like update_project_role or delete_global_role beyond the name/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?

Provides contextual caveats about availability depending on edition, license, and permissions, and notes possible 404 or empty-list responses. However, it does not explicitly say when to use this tool versus alternatives such as update_project_role or delete_global_role.

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 destructiveHint=true, idempotentHint=true and openWorldHint=true, so the safety profile is covered. The description adds only a REST endpoint string and says nothing about irreversibility, effect on assigned jobs, or required permissions, so it contributes almost nothing 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?

Two short sentences, purpose front-loaded, no filler. The REST path sentence is marginally redundant with the tool name but does convey the resource hierarchy, so it roughly earns its space.

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 destructive mutation with no output schema and zero parameter documentation; the description should at least state whether deletion is permanent, what happens to the runner's jobs, or what permissions are needed. Instead it restates the name and a raw endpoint.

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 two integer params carry no descriptions. The URL template 'DELETE /project/{project_id}/runners/{runner_id}' does map each parameter to its role and confirms the project→runner hierarchy, but adds no format, validation, or edge-case detail beyond that.

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 project runner'), which is enough to separate it from delete_global_runner and update_project_runner by name. It does not explicitly contrast itself with those siblings, so it stops short of a 5.

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

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

The description gives no when-to-use guidance, no prerequisites (e.g. pausing/disabling the runner first, permission requirements), and never names the alternative tool for global runners. The agent must infer usage entirely from 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?

Annotations already declare destructiveHint=true, idempotentHint=true, and readOnlyHint=false, so the agent knows this is a destructive, repeatable write. The description adds only the REST endpoint mapping; it says nothing about whether the removed user's tasks, schedules, or permissions are reassigned or lost. With annotations carrying the safety profile, 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?

Two terse sentences, front-loaded with the action and resource. The endpoint clause is mildly redundant but harmless; nothing bloats the description.

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

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

For a two-parameter destructive mutation with no output schema, the definition is adequate to call it but omits consequences (what access or resources the user loses) and any confirmation/error behavior, which matter for a destructive operation.

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

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

Schema description coverage is 0% for both parameters, so the description carries the burden, but it only echoes them implicitly via the URL template. It never explains that user_id identifies the member to remove or where project_id comes from, leaving both 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?

The description states a specific verb and resource ('Removes user from project'), which implicitly distinguishes it from delete_user (removes from the system) and delete_project (removes the whole project). It does not explicitly name those siblings, so differentiation is inferred rather than stated.

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

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

There is no guidance on when to use this tool versus alternatives like leave_project, update_project_user, or delete_user, nor any prerequisites (e.g., admin rights). The usage is only implied by the tool name.

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

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

Annotations already declare destructiveHint=true, idempotentHint=true and openWorldHint=true, so the safety profile is covered structurally. The description adds nothing beyond restating the HTTP verb – no cascade effects, no confirmation requirements, no indication of whether the deletion is immediate or asynchronous, and no auth/permission notes.

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

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

Two sentences, front-loaded with the action and followed by the endpoint; nothing is padded. The brevity is efficient but tips toward under-specification rather than true conciseness.

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

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

For a destructive, non-reversible operation with no output schema and zero parameter documentation, the description is far too thin. An agent gets no information about consequences of deletion, error conditions, or how the call reports success.

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 both parameters are undocumented integers with only a minimum constraint. The URL template gives the only semantic hint, mapping project_id and repository_id to path segments, but it adds nothing about format, scope, or what happens when an ID is invalid.

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 ('Removes repository') and even names the exact endpoint, so there is no ambiguity about what the call does. It does not explicitly distinguish itself from siblings like update_repository or get_repository, but the verb makes the distinction self-evident.

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 update_repository or list_repositories, no preconditions, and no warning about what deleting a repository implies for attached templates or other dependents. The agent must infer all 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?

Annotations already declare destructiveHint=true, idempotentHint=true, and openWorldHint=true, so the core safety profile is covered. The description adds only the endpoint path and does not explain irreversibility, cascade effects, or required permissions beyond what annotations already 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?

Two short sentences with no filler; the verb and endpoint are front-loaded and immediately useful.

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, open-world delete operation with no output schema and no documented parameters, the description is too thin. It should at least explain what is removed and any important side effects, even if annotations cover the safety hints.

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 both required integer parameters are undocumented in structured data. The endpoint path implies which parameters are needed, but the description does not explain their meaning, constraints, or relationships.

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 ('Deletes schedule') and adds the REST endpoint, which makes the project/schedule scoping clear. It does not distinguish itself from siblings such as delete_template or set_schedule_active beyond the name, but the operation is still 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 guidance on when to use this instead of alternatives like set_schedule_active, update_schedule, or deleting a parent template. No prerequisites, warnings, or exclusion conditions 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?

Annotations already carry destructiveHint=true, idempotentHint=true and openWorldHint=true, so the description adds no safety context of its own. It does not say what is permanently destroyed (stored credentials/encryption material), whether deletion fails if the storage is in use, or whether it can be undone.

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 fragments with no padding and the action front-loaded. However, the extreme brevity is under-specification rather than efficiency, and the path template substitutes for explanatory prose.

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, irreversible-sounding operation with no output schema and zero parameter descriptions, the description omits consequences, dependency checks, and permission requirements. An agent has enough to form the call but not enough to make a safe decision about 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 description coverage is 0%, so the description is the only source of parameter meaning, yet it only places {project_id} and {storage_id} in a URL template. It does not explain what a secret storage ID is, how to obtain it (e.g., via list_secret_storages), or whether project_id must match the storage's owner.

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?

"Remove" is a vague verb on its own, but the REST route DELETE /project/{project_id}/secret_storages/{storage_id} disambiguates the resource as a secret storage scoped to a project. It identifies the action and target, but never names any of the many sibling delete_* tools, so nothing distinguishes it beyond the endpoint path.

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 alternatives. Nothing warns that a storage still referenced by integrations may need unlinking first (the sibling get_secret_storage_references hints at such dependencies), and no prerequisites or safe-usage context 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?

Annotations already declare destructiveHint=true, idempotentHint=true, openWorldHint=true, and readOnlyHint=false. The description adds edition/license/permission constraints and route-specific 404/empty-list caveats that are not in the annotations, giving useful operational context beyond the structured fields.

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 plus the endpoint are front-loaded with the action, followed by the key availability caveat. Every sentence adds value 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 zero-parameter destructive endpoint with rich annotations, the description covers availability constraints and the route. It does not spell out irreversibility or side effects on related resources, but the destructive annotation already signals risk, so the remaining gap 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?

The tool has zero parameters, which sets the baseline at 4. The description adds no parameter detail, which is appropriate because the schema is empty and there are no parameter semantics to clarify.

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 the specific verb 'delete' and resource 'subscription', and the DELETE /subscription endpoint confirms the operation. An agent can distinguish it from get_subscription, refresh_subscription, and activate_subscription by the verb alone.

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?

Provides prerequisites such as Semaphore edition, license, and permissions, and warns that some Community routes return 404 or empty lists. However, it does not explicitly say when to use this versus the sibling subscription tools or when deletion is inappropriate, so usage is implied rather than directly guided.

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 destructiveHint=true, idempotentHint=true and openWorldHint=true, so the safety profile is covered. The description does add one real piece of behavioral context — that the task's output is removed too — but says nothing about irreversibility, cascade effects, or authorization requirements.

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

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

Two short sentences, front-loaded with the action and its side effect, with the endpoint as supporting detail. No filler, though the endpoint syntax is low-value for an agent that already has 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 destructive, no-output-schema tool, the definition covers the core action and the output deletion but omits confirmation requirements, what happens to dependent objects, and how to choose between this and delete_global_task. Adequate to call safely only because annotations carry the destructive flag.

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 partially does: the path template 'DELETE /project/{project_id}/tasks/{task_id}' clarifies that both integers are path segments rather than body fields. It adds no constraints, formats, or validation notes beyond that.

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 ('Deletes task'), plus a distinguishing scope detail ('including output') that a bare 'delete' would not convey. It does not differentiate from the sibling delete_global_task, so an agent cannot tell which deletion path applies from this text alone.

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 statement of when to use this versus delete_global_task / delete_project / stop_task, and no prerequisites or warnings beyond the word 'Deletes'. The agent must infer everything from 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?

The annotations already disclose that this is destructive, idempotent, not read-only, and open-world, so the description adds little behavioral context. It does not explain what else may be affected by deleting a template, whether deletion is reversible, or what permissions are required.

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 operation stated first and the endpoint second. It is efficient, though the endpoint path mostly restates the parameter names rather than adding much explanatory 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?

For a destructive operation with no output schema, the description is too thin. It omits side effects, permissions, confirmation expectations, and the consequences of deleting a template, leaving the agent with only the endpoint and verb.

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 carry the burden for parameter meaning. It only repeats project_id and template_id as URL path placeholders and adds no explanation of what those identifiers select or any constraints beyond the schema's integer minimum.

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 gives a specific verb and resource: 'Removes template', and reinforces it with the DELETE endpoint path. It is clear what the tool does, though it does not explicitly differentiate itself from nearby destructive siblings such as delete_template_permission or detach_template_inventory.

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 prerequisite checks, and no warning about confirming a destructive template deletion. The operation is implied only by the verb 'Removes'.

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 destructiveHint=true, idempotentHint=true, and openWorldHint=true, so the safety profile is covered. The description adds only the REST path and says nothing about what is removed, required permissions, or side effects 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?

Two short, front-loaded sentences with no filler. The only weakness is the unexplained abbreviation 'Perm' and the raw endpoint notation, which is slightly cryptic but still compact.

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

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

For a destructive operation with no output schema and no parameter descriptions, the definition is thin. It omits prerequisites, failure modes, and the effect of deleting the permission, leaving the agent under-informed.

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. The endpoint path maps each of the three required IDs to its role in the resource hierarchy, but it does not explain what a perm_id represents or how to obtain one.

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 delete action on a template permission, and the HTTP endpoint clarifies the resource nesting (project → template → perm). However, the abbreviated 'Template Perm' and lack of explicit sibling differentiation (vs. update/get/list_template_permissions) keep it at merely adequate.

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

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

No guidance on when to use this tool versus alternatives such as update_template_permission or delete_template. The agent must infer from the name that this removes a single permission assignment.

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 destructiveHint=true, idempotentHint=true and openWorldHint=true, so the safety profile is covered. The description goes beyond that by warning that the endpoint can fail with 404 or empty results depending on edition/license/permissions — a failure mode an agent would otherwise misread as 'alias not 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?

Three short sentences, verb-and-resource statement front-loaded, endpoint last. The conditional-availability sentence is slightly vague ("some Community routes") but still earns its place as a caveat.

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 three-path-param delete with a full annotation set and no output schema, the definition covers identity, route, and failure caveats adequately. What is missing is whether deletion cascades or is recoverable, but destructiveHint already signals the risk.

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 carry the load; the embedded path template (DELETE /project/{project_id}/inventory/{inventory_id}/terraform/aliases/{alias_id}) does map each of the three required params to its role in the hierarchy. It adds no type, format, or lookup guidance beyond that mapping.

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 terraform alias") and pins it down with the exact REST route, so an agent can distinguish it from create_terraform_alias, update_terraform_alias and delete_terraform_state. It never explicitly names those siblings, but the resource scoping is unambiguous.

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

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

The availability note (edition, license, permissions, 404s on Community routes) gives useful preconditions for attempting the call, which most delete tools omit. However, there is no guidance on when to prefer this over update_terraform_alias or how to verify the alias first via get_terraform_alias/list_terraform_aliases.

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 destructiveHint=true, idempotentHint=true, and openWorldHint=true, but the description adds genuinely new operational context: availability gated by Semaphore edition, license, and permissions, and that some Community routes return 404 or empty lists. That tells the agent how to interpret a failed delete rather than assuming the state was absent.

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

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

Two compact sentences: the action is front-loaded, and the caveat follows. The endpoint echo is mildly redundant but cheap and useful for disambiguation. No filler.

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

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

For a 3-param destructive tool with no output schema, the description covers what the tool does, how it is scoped, and the main failure mode. It stops short of stating irreversibility or success/error semantics explicitly, but annotations carry the destructive profile.

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

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

Schema description coverage is 0% and all three params are bare integers in the schema. The description partially compensates by presenting the REST path, which maps project_id, inventory_id, and state_id to their roles in the resource hierarchy. It adds no further format or constraint detail, so it lands at the baseline-plus level for a low-coverage 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 plus resource ("delete terraform state"), which is unambiguous against siblings like get_terraform_state, list_terraform_states, or delete_terraform_alias. It does not explicitly name a sibling to differentiate, which is the only thing keeping it out of 5 territory.

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 a single obvious use (remove an existing state) and warns that availability depends on edition, license, and permissions, so an agent knows failures may be environmental. It gives no explicit when-to-use vs alternatives or prerequisites beyond that caveat.

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 declare destructiveHint=true, idempotentHint=true, and openWorldHint=true, so the safety profile is covered. The description adds nothing beyond restating the endpoint — it doesn't mention irreversibility, cascade effects on the user's owned resources, or required admin rights, which is the added value expected when annotations are 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?

Two short fragments with zero padding, and the core verb is front-loaded. It is efficient but borders on under-specification rather than true conciseness.

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

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

For a destructive user-deletion tool with no output schema, the description is too thin: it omits whether deletion is permanent, what happens to related resources, and any authorization prerequisites. Annotations cover the read/write and destructive flags, but the operational context an agent needs 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?

One required parameter with 0% schema description coverage. The path fragment "/users/{user_id}" hints that user_id identifies the target, but no format, range, or sourcing guidance is added beyond what the raw name implies, so it does not compensate for the 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 and resource ("Deletes user") and even names the HTTP endpoint, so the operation is unambiguous. However, it does nothing to distinguish it from siblings like delete_project_user or disable_user_totp, leaving an agent to infer scope from the name alone.

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., disable_user_totp, delete_project_user, or update_user to deactivate). The description offers no preconditions such as whether the user must be empty of projects first.

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

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

Annotations already declare destructiveHint, idempotentHint, and openWorldHint, so safety profile is covered. The description adds only the REST endpoint, with no mention of what exactly is removed, whether it's reversible, or permission requirements—little value beyond structured fields.

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?