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

The annotation readOnlyHint:false already signals a state-changing operation. The description adds meaningful behavioral context by stating that activation causes the workflow to run automatically on triggers, which is a key consequence beyond the raw mutation indication.

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

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

The description is a single concise sentence that front-loads the action and purpose without any redundant information.

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

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

For a tool with one parameter, full schema coverage, and no output schema, the description provides sufficient context about its purpose and effect. It does not cover edge cases, but the simplicity of the operation reduces the need for additional detail.

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

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

The input schema already documents the single parameter 'id' with description 'Workflow ID to activate' (100% coverage). The tool description does not add additional semantic detail about the parameter, so a baseline score of 3 is appropriate.

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

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

The description uses the specific verb 'Activate' with the resource 'a workflow' and explains the resulting behavior ('runs automatically on triggers'), which clearly differentiates it from sibling tools like deactivate_workflow or run_workflow.

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

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

The phrase 'so it runs automatically on triggers' provides clear context for when to use this tool (to enable automatic trigger-based execution). It does not explicitly name alternatives, but the context is sufficient to imply use cases.

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

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

The description adds no behavioral context beyond what the readOnlyHint=false annotation already implies. There is no mention of side effects like duplicate name handling, permission requirements, or what the response includes. No contradiction 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 a single sentence that directly states the tool's function with no unnecessary words. It is appropriately sized for a simple 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?

With no output schema and minimal annotations, the description should explain return values or duplicate behavior, but it does not. The schema covers parameters thoroughly, but lacks contextual information about the operation's outcome, making the overall description incomplete.

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

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

The input schema provides 100% parameter descriptions, including examples and cross-reference for the type parameter. The tool description itself adds no additional parameter meaning, so the baseline score of 3 is appropriate.

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

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

The description 'Create a new credential instance' uses a specific verb and resource, clearly identifying the action. It distinguishes from siblings like update_credential and delete_credential by the 'create' verb and 'credential' resource.

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

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

No guidance is given on when to use this tool versus alternatives. It doesn't mention that list_credential_types should be consulted for valid type values, nor does it exclude update_credential for existing credentials. Only the implied use case of 'creating' is present.

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

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

Annotations already indicate readOnlyHint=false, and the description simply states 'Create' without adding additional behavioral context. It does not disclose uniqueness constraints, duplicate handling, idempotency, or what the operation actually returns, so it adds little beyond the annotation.

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

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

The description is a single, direct sentence: 'Create a new tag.' It is concise and front-loaded with no unnecessary words or repetition of schema 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?

Given the tool's simplicity (one parameter, no output schema, and annotations present), the description is minimally sufficient. However, it does not mention return values or duplicate behavior, leaving minor gaps. It is 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 100% (the 'name' property is described as 'Tag name'), so the schema carries full parameter meaning. The description itself adds no parameter information, but the baseline of 3 applies due to high schema coverage.

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

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

The description uses a specific verb and resource ('Create a new tag'), clearly stating the action. It naturally distinguishes itself from sibling tools like update_tag, delete_tag, and list_tags by the 'create' action.

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

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

The description implies when to use the tool (when you want to create a tag) but provides no explicit guidance about prerequisites, when not to use it, or alternatives. It falls under 'implied usage' rather than clear contextual 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?

The description adds no behavioral context beyond the readOnlyHint=false annotation. It does not disclose whether creating a variable with an existing key overwrites it or fails, nor does it mention any permission requirements. This is a significant gap for a mutation tool.

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

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

The description is a single sentence, immediately front-loaded with the action and resource. Every word earns its place, 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?

Given the tool's simplicity (two well-documented parameters, no output schema) and the sibling set clarifying the CRUD context, the description is minimally adequate. However, it lacks important edge-case behavior (e.g., duplicate keys) and explicitly identifies no when-not-to-use, leaving the completeness somewhat shallow.

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 for the two parameters is 100%, and the schema descriptions for 'key' and 'value' already explain their meaning and example values. The tool description adds no additional parameter semantics beyond what the schema provides, so baseline 3 applies.

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

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

The description uses a specific verb ('Create') and resource ('custom environment variable in n8n'), clearly distinguishing this from sibling tools like update_variable, delete_variable, and list_variables. It precisely states the tool's function.

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

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

The description implies usage for creating a new variable but provides no explicit guidance on when to use it versus updating an existing variable, nor does it mention any prerequisites or alternatives. It lacks exclusions such as 'use update_variable if the key already exists.'

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

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

Annotations already indicate readOnlyHint=false and destructiveHint=false, so the write nature is conveyed. The description adds the 'Optionally activate immediately' behavior, which is a useful extra context. However, it does not disclose other behavioral traits such as permissions needed, return value, or side effects beyond creation, so it stays at a baseline level.

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

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

The description is two sentences, front-loaded with the primary action, and contains no fluff. Every phrase adds meaning, including the optional activation note.

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

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

Given the tool has 6 parameters, nested objects, and no output schema, the description provides only a high-level overview. It does not mention what is returned or any error conditions. However, the schema carries the burden for parameters, so the description is minimally adequate but leaves gaps regarding expected output and usage 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 100%, so the baseline is 3. The description itself does not add parameter-level meaning beyond what the schema already provides (e.g., the schema explains connections format and references list_common_nodes). The description's mention of 'nodes, connections, and settings' is redundant with parameter names, so no additional value is 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 clearly states the verb 'Create' and the resource 'n8n workflow', specifying that it includes nodes, connections, and settings. It also mentions optional activation, which distinguishes it from related tools like update_workflow or duplicate_workflow.

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

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

The description implies usage when creating a new workflow but does not explicitly state when to use this tool versus alternatives like update_workflow or import_workflow. There is no exclusionary language or reference to sibling tools, so it meets only the 'implied usage' threshold.

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?

readOnlyHint=false already indicates a mutation, and the description adds meaningful context by explaining the operational effect ('stops running on triggers'). It does not disclose whether currently running executions are affected or if specific permissions are required, but the core state change is clearly described.

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

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

One concise sentence that states purpose and effect without any filler. Every word earns its place.

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

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

The tool is simple (1 parameter, no output schema), and the description covers the main purpose. It could mention impact on existing executions, but given the low complexity and presence of annotations, the description is adequate.

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

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

The schema provides 100% coverage with the description 'Workflow ID to deactivate', so the description adds no extra parameter semantics. According to the rubric, baseline 3 is appropriate when the schema fully documents the parameter.

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

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

The description uses a specific verb ('Deactivate') and resource ('workflow') and clearly states the effect ('stops running on triggers'). This distinguishes it from sibling tools like activate_workflow and delete_workflow.

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

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

The description implies usage when you need to disable workflow triggers, but it doesn't explicitly mention alternatives, exclusions, or prerequisites. Sibling tools like activate_workflow provide context, but the description itself gives no direct 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?

The annotations already declare destructiveHint=true and readOnlyHint=false, so the agent knows this is destructive. However, the description adds no behavioral context beyond the annotations—it does not mention irreversibility, permissions, or what happens after deletion, so it fails to provide additional transparency.

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

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

The description is extremely terse (3 words) but is under-specified and redundant. It does not earn its place because it merely repeats what the tool name already conveys, making it a waste rather than a concise, value-adding explanation.

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

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

Given the destructive nature of the operation and the absence of an output schema, the description offers minimal context. It does not explain the effects of deletion, expected return values, or any constraints, leaving the agent with an incomplete picture for a potentially impactful action.

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

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

Schema description coverage is 100% (the 'id' parameter has a meaningful description). The description itself does not expand on parameters, but the schema already handles the semantics, so baseline 3 is appropriate.

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

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

Description 'Delete a credential.' is a direct restatement of the tool name 'delete_credential' without adding any new information. It is a tautology that does not differentiate from siblings like update_credential or get_credential beyond the verb.

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

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

No guidance is provided on when to use this tool versus alternatives such as update_credential or deactivate_workflow. There are no stated prerequisites, side conditions, or exclusions, leaving the agent without context for appropriate 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?

The description aligns with the annotations (destructiveHint=true, readOnlyHint=false) and adds the specific target of destruction: an execution record. It does not add caveats like whether running executions can be deleted or if deletion is permanent, but it does disclose the object being 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 a single, clear sentence with no redundant or filler content. It is appropriately concise for a simple delete operation.

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

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

Given the low complexity (one parameter, no output schema) and the strong hint from annotations, the description is sufficiently informative for an agent to understand the core operation. However, it could have added note about whether deletion applies to executions in any state, but this is not a critical 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 input schema fully describes the single parameter ('Execution ID to delete'), so schema description coverage is 100%. The tool description adds no additional parameter semantics beyond what the schema already provides, warranting the baseline score.

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 'Delete an execution record' uses a specific verb and resource, making the tool's function immediately clear. It distinguishes itself from sibling tools like delete_workflow, delete_tag, and delete_credential by specifying 'execution record'.

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 such as stop_execution or retry_execution. The description simply states the action without providing context 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 and readOnlyHint=false. The description's word 'permanently' essentially restates the destructiveHint, adding no new behavioral information. It does not disclose any side effects, required permissions, or error behavior.

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

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

A single sentence with no fluff, front-loading the action clearly. Appropriate for the tool's simplicity, though it could add more context without becoming 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?

Given the low complexity (1 param, no output schema) and the presence of annotations covering destructive behavior, the description is minimally adequate. However, it lacks any contextual detail such as consequences of deleting a tag still in use, which limits its completeness.

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

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

The input schema has only one parameter 'id' with a description 'Tag ID to delete', achieving 100% coverage. The description provides no additional parameter semantics beyond the schema.

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

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

The description clearly states the action (Delete) and resource (tag), with 'permanently' indicating irreversibility, distinguishing it from sibling operations like create_tag and update_tag.

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. It does not mention any prerequisites or contexts, leaving the agent to infer 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?

The description adds no behavioral context beyond what annotations already state. DestructiveHint and readOnlyHint cover the safety profile, but the description does not disclose whether deletion is permanent, requires permissions, or has cascading effects.

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

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

The description is a single, concise sentence with no fluff. It is well-structured for a simple tool, though it could include more useful context without becoming verbose.

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

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

For a simple delete tool with one parameter and strong annotations, the description is minimally adequate. However, it omits any mention of irreversibility or side effects, which could be important context despite the destructiveHint annotation.

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

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

The input schema already provides complete descriptions for the single parameter (id as 'Variable ID to delete'), resulting in 100% schema coverage. The description adds no additional meaning beyond the schema, so a baseline score of 3 is appropriate.

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

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

The description uses a specific verb 'delete' and explicitly names the resource 'environment variable', making the tool's purpose unambiguous. This clearly distinguishes it from sibling delete tools for other resources like workflows, credentials, and tags.

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, nor any prerequisites or exclusions. While the resource name implies its use case, there is no explicit context about when deletion is appropriate or what to consider 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 indicate destructiveHint=true and readOnlyHint=false, but the description adds the context of permanence (irreversible) and identifies the exact resource destroyed (workflow). This goes beyond annotations by clarifying the consequence of the action.

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

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

A single, direct sentence that is front-loaded with the action and resource. Every word adds value, with no redundancy 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 simple delete operation with one parameter and no output schema, the description is mostly sufficient. It covers the core purpose and relies on annotations for safety context. Missing elements include return value or error scenarios, but these are not critical for a basic delete 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?

The schema provides 100% coverage with 'Workflow ID to delete', so the description does not need to add parameter details. The baseline of 3 applies since the schema fully documents the parameter, and the description merely reinforces the 'by ID' concept.

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 it permanently deletes a workflow by ID. The verb 'delete' and resource 'workflow' are specific, and it distinguishes itself from siblings like delete_execution (which deletes executions) and get_workflow (which retrieves).

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

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

The description implies usage when a workflow must be removed, but it does not explicitly mention alternatives or exclusions. For instance, it does not contrast with deactivate_workflow, which would be the non-destructive alternative. The 'Permanently' suggests irreversibility but no explicit when-to-use guidance.

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

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

Annotations declare readOnlyHint=false and destructiveHint=false, indicating a non-destructive write. The description adds only that the source must be an existing workflow (already implied by the parameter schema) and does not explain copy semantics, such as what gets duplicated or whether the original is unchanged.

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

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

The description is a single sentence with no filler, making it concise. However, it is under-specified and largely restates the tool name, lacking additional context despite being appropriately short.

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?

While the schema covers parameters and annotations provide basic safety hints, the description omits important operational context for a mutation tool: no mention of the return value, potential errors, or how the duplicate is handled (e.g., default name behavior). The overall picture is incomplete for an AI agent.

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

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

The input schema fully documents both parameters ('id' and 'name') with descriptions, achieving 100% schema description coverage. The description adds no parameter-specific detail beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description uses a specific verb ('Duplicate') and resource ('an existing workflow'), clearly indicating the action. However, it does not differentiate from related tools like create_workflow or export_workflow, which could also be used in copying contexts.

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

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

No guidance is provided on when to use this tool instead of create_workflow, import_workflow, or export_workflow. The description does not mention any prerequisites or exclusions, leaving the agent to infer appropriate usage.

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

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

Annotations already provide readOnlyHint=true, so the read-only nature is covered. The description adds that the output is a formatted JSON structure, but does not disclose response details, size limits, or whether the export includes all workflow metadata. This is adequate but not rich.

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

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

The description is a single, well-constructed sentence that immediately states the verb and resource. It contains no filler and is perfectly concise.

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

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

Given the tool's simplicity (one parameter, no output schema, annotations present), the description covers the essential purpose and output nature. It could be slightly more explicit about the return structure or differentiation from get_workflow, but it is largely complete for its 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 coverage for the single 'id' parameter is 100%, with a clear description 'Workflow ID to export'. The description adds no additional meaning beyond the schema, so a baseline of 3 is appropriate.

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

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

The description clearly states the action (Export), the resource (workflow), and the output format (formatted JSON structure). It also gives use cases (backup or sharing), which distinguishes it from the likely retrieval semantics of get_workflow.

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

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

The description implies usage for backup or sharing but does not explicitly contrast with siblings like get_workflow or provide when-to-use/when-not-to-use guidance. No exclusions or alternative suggestions are given.

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

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

The annotation readOnlyHint is complemented by the explicit statement 'secret data is hidden', which is a behavioral guarantee beyond the schema. This informs the agent that the tool returns only metadata, not the credential secret.

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

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

The description is a single sentence that concisely conveys the purpose and the key limitation about secret data. Every word earns its place with no redundancy.

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

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

For a simple get-by-id tool with one required parameter, the description covers the essential points: retrieval of metadata, hidden secrets, and the ID parameter. It doesn't enumerate metadata fields, but given the lack of an output schema and the tool's simplicity, it is sufficiently complete.

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

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

The schema already defines the single parameter `id` with description 'Credential ID' at 100% coverage. The tool description adds no extra meaning about the ID format or how to obtain it, so the baseline score of 3 applies.

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

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

The description states a specific verb 'Get' and resource 'credential', and specifies that it returns metadata with secret data hidden. This clearly distinguishes it from sibling tools like list_credentials, update_credential, and delete_credential.

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

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

The description clearly implies usage for fetching a single credential's metadata by ID. It does not explicitly state when not to use it or point to alternatives, but the sibling context and the one-parameter schema make the intended use obvious.

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 readOnlyHint annotation already indicates a safe read operation. The description adds that the tool returns node-by-node input and output data, which clarifies the response scope, but it doesn't disclose the default behavior of includeData (though schema does) or any error behaviors.

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

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

One short sentence with no filler; front-loads the core purpose.

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

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

For a simple read-only getter with two parameters and a clear scope, the description is adequate but not exhaustive—it doesn't mention the return format or that includeData toggles data inclusion, though the schema covers that. It would be more complete with a note about using list_executions to obtain the ID.

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

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

The schema already documents both parameters with descriptions (id and includeData), achieving 100% coverage. The description adds no additional semantics beyond what the schema provides, so it's at the baseline for high coverage.

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

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

The description clearly identifies the resource (specific execution), the action (get), and the scope (node-by-node input/output data), which differentiates it from sibling tools like list_executions (list) and delete_execution (delete).

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

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

The description implies usage when detailed node-level data is needed, but it does not explicitly specify when to choose this over list_executions or provide prerequisites like needing the execution ID first. No exclusions or alternatives 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 mark readOnlyHint=true, so the safe read nature is covered. The description adds no further behavioral context such as error handling or authentication. It is consistent with annotations but does not go beyond them.

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

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

A single sentence with no filler. It conveys the essential information clearly and efficiently.

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

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

The tool is simple with one parameter and a read-only annotation. The description adequately conveys the purpose and input, though it does not mention output format or error behavior. For this complexity, this is sufficient.

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

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

Schema coverage is 100% with the id parameter described as 'User ID'. The description's 'by ID' simply reinforces the parameter's role without adding extra meaning. Baseline of 3 applies given high schema coverage.

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

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

The description clearly states the tool's action ('Get') and resource ('details of a specific user') with a distinguishing scope ('by ID'). This uniquely identifies it from sibling tools like list_users, which lists multiple users.

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

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

The phrase 'specific user by ID' implies the tool is for retrieving a single user when an ID is available, contrasting with list_users for multiple users. It provides clear context but does not explicitly name alternatives 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?

The readOnlyHint annotation already establishes the read-only nature. The description adds useful context about the response content (nodes, connections, settings), which is beyond the annotation. However, it does not disclose additional behavioral traits such as error handling, auth needs, or rate limits, though the annotation lowers the burden.

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

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

The description is a single, well-structured sentence that front-loads the main action and resource, followed by a concise list of included details. No unnecessary words or redundancy.

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

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

For a simple read-only get tool with one parameter and no output schema, the description provides enough context: it names the resource and lists the expected components (nodes, connections, settings). It could mention error cases or required permissions, but these are not essential for a basic retrieval 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?

The input schema already fully documents the single parameter 'id' with description 'Workflow ID', and coverage is 100%. The description does not add syntax or format details beyond what the schema provides, so the baseline of 3 applies.

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

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

The description clearly states the tool's action with a specific verb (Get) and resource (workflow), and further defines the scope via 'full details including nodes, connections, and settings'. This distinguishes it from siblings like list_workflows, delete_workflow, and update_workflow.

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

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

The description implies usage for retrieving detailed workflow information but does not explicitly state when to prefer this over list_workflows or other alternatives. The phrase 'full details' suggests a contrast with listing, but no explicit exclusions or alternative guidance is provided.

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

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

The description is a minimal one-liner and does not disclose behavioral details beyond what the annotation already indicates. The annotation readOnlyHint=false signals a write operation, and 'Import' aligns with that. However, the description does not mention whether import creates a new workflow, overwrites an existing one, or what side effects might occur (e.g., validation failures). The agent is left without crucial operational context.

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

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

The description is a single, focused sentence that is immediately clear and front-loaded. It contains no unnecessary words or fluff, making it highly concise for the information it conveys.

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

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

Given the absence of an output schema, the description should explain return values, but it does not. It also fails to clarify the operational semantics—specifically whether import creates a new workflow or updates an existing one. This is a notable gap for a write operation, even with two simple parameters. The description is too sparse to fully inform an agent in a complex tool ecosystem.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no new parameter semantics; it only references the JSON string source, which is already detailed in the workflowJson schema. The activate parameter is not mentioned, and the description adds no value beyond what the schema already provides.

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

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

The description clearly states the tool's action ('Import'), the resource ('a workflow'), and the specific input source ('a JSON string definition'). This distinguishes it from sibling tools like create_workflow, which likely builds workflows from individual fields, and export_workflow, which does the opposite. The purpose is unambiguous and specific.

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

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

The description provides no guidance on when to use this tool compared to alternatives. It does not mention that import is specifically for restoring from JSON or when a user has a complete workflow definition. There are no explicit exclusions or alternative tool references, leaving the agent to infer usage context from the tool 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?

The readOnlyHint annotation already marks this as a safe read operation. The description adds the content type (docs and snippets) but no further behavioral details like rate limits or exactly what the response contains. Since annotations cover safety, a 3 is appropriate.

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

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

The description is a single concise sentence that front-loads the action and resource, listing examples without unnecessary elaboration. Every word earns its place.

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

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

With no output schema, the description suitably explains what the tool returns (documentation and JSON template snippets) and even enumerates the included node types. The optional filter parameter is already well-covered by the schema, and the tool is simple enough that this description is complete.

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

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

The sole parameter 'category' is fully documented in the schema with an enum, default, and description (100% coverage). The tool description adds no additional parameter information, so the baseline of 3 applies.

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

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

The description uses a specific verb 'Get' with a clear resource: 'documentation and JSON template snippets for common n8n node types'. It lists exact node types (Webhook, Schedule, etc.), making it distinct from sibling tools that manage workflows or credentials.

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 context is clear: this is the tool to use for obtaining reference documentation and JSON templates for common nodes. It doesn't explicitly mention alternatives or exclusions, but its unique purpose among siblings makes usage evident.

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

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

The annotations declare readOnlyHint=true, so the read-only behavior is covered. However, the description adds no additional behavioral context, such as what information is returned or any caveats, making it minimally informative beyond the tool name.

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

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

The description is extremely concise, consisting of a single sentence with no wasted words. It is front-loaded and directly states the action.

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

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

For a simple listing tool, the description is minimal. Without an output schema, it lacks information about the response structure (e.g., whether credential secrets are included). It also does not differentiate from siblings like get_credential, leaving a gap for the agent.

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

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

Schema description coverage is 100%, with each parameter (name, limit, cursor) documented. The description adds no extra meaning, so the baseline score of 3 is appropriate.

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

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

The description clearly states it lists saved credentials, with a specific verb (list) and resource (credentials). It distinguishes from the sibling get_credential, which fetches a single credential.

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

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

No guidance is provided on when to use this tool versus alternatives, such as get_credential for individual retrieval or list_credential_types for types. No context for filtering or pagination is given beyond the schema defaults.

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

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

The annotation readOnlyHint=true already communicates that this is a safe, read-only operation. The description adds no extra behavioral context such as return format, pagination, or side effects. It simply restates the listing action, providing minimal value beyond the annotation.

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

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

The description is a single, front-loaded sentence with no redundancy. It states the action, resource, context, and optional capability without wasted words.

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

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

For a simple list operation with one optional parameter and read-only annotation, the description is largely sufficient. It identifies the resource and scope. However, a brief note about how this relates to credential creation or a pointer to list_credentials could enhance completeness, though it is not essential given the low 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 coverage is 100% and the 'search' parameter has a clear description ('Filter credential types by keyword (e.g. 'slack', 'ai', 'postgres')'). The description's mention of 'optional search query' adds no new information beyond what the schema already provides, so baseline 3 is appropriate.

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

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

The description starts with the specific verb 'List' and identifies a clear resource: 'supported credential types in n8n'. This distinguishes it from sibling tools like list_credentials, which lists actual credentials, and get_credential, which fetches a single credential. The mention of 'optional search query' further clarifies its scope.

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

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

The description implies usage (e.g., to see available credential types) but provides no explicit when-to-use/when-not-to-use guidance or mention of alternatives. It does not contrast with list_credentials or explain when a user would need this over other tools. Usage is inferred from the tool name and description rather than explicitly stated.

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

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

The annotation readOnlyHint=true already covers the safety profile, so the description adds little beyond that. However, it claims a 'date' filter that is not supported by the schema, which is a misleading behavioral disclosure. It also does not mention pagination via cursor or the includeData behavior, despite these being important for setting expectations.

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

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

The description is a single, front-loaded sentence that is concise and easy to parse. While it earns points for brevity, the inclusion of the erroneous 'date' reference is a structural inefficiency that prevents a perfect score.

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

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

Given the tool's moderate complexity (5 optional params, no output schema), the description is minimally viable but incomplete. It does not mention pagination behavior or the warning that includeData produces large responses, both of which are relevant to usage. The false 'date' claim also undermines completeness. Most necessary context is available in the schema, but the description could do more to tie it together.

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

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

The schema provides 100% parameter description coverage, so the baseline is 3. However, the description adds a non-existent 'date' filter, which could mislead an agent into looking for a parameter that does not exist. It also only restates workflowId and status without adding semantic value beyond the schema.

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

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

The description clearly states it lists workflow executions with a specific verb and resource, distinguishing it from get_execution and list_workflows. However, it inaccurately mentions filtering by 'date' when no date parameter exists in the schema, which detracts from precision.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives like get_execution. The name and phrasing imply it is for listing multiple executions, but this is not stated explicitly, leaving room for ambiguity.

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 readOnlyHint annotation already indicates a safe read operation, so the description does not need to restate that. However, the description does not add any behavioral context beyond what the name and schema provide, such as pagination behavior or the fact that 'all' tags may require multiple pages. The description adds minimal value beyond the annotation.

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

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

The description is a single concise sentence: 'List all workflow tags.' It contains no unnecessary words and is immediately understandable.

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

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

The tool has no output schema and only a two-parameter input schema with full coverage. The description is minimal and does not mention that the list is paginated (though the schema implies it via limit and cursor) or what fields a tag object contains. While the tool is simple, the lack of output schema means the description is not fully complete on its own.

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 descriptions cover 100% of the parameters (limit and cursor), so the baseline is 3. The description does not add any additional meaning to the parameters, but the schema already provides sufficient detail.

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 'List all workflow tags' uses a specific verb and resource, making it immediately clear what the tool does. It distinguishes itself from sibling tools like list_workflows or tag-management tools by explicitly naming the resource (workflow tags).

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

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

The description implies the tool is used to retrieve workflow tags, but it does not explicitly state when to use it versus alternatives, nor does it mention any exclusions or prerequisites. The usage context is clear enough for a simple list operation, but there is no explicit guidance.

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

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

The readOnlyHint annotation already signals a safe read operation, lowering the burden. The description adds minor context with 'registered users' but does not disclose pagination behavior, response structure, or any ordering/filtering details that would help the agent understand the tool's full behavior.

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

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

The description is a single, concise sentence: 'List registered users in the n8n instance.' It is front-loaded, free of unnecessary words, and appropriately sized for a simple list tool.

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

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

For a simple read-only list tool with well-documented parameters and a read-only annotation, the description provides a clear purpose and sufficient context to invoke it. However, the absence of an output schema means pagination semantics and return structure are not explained, leaving a minor gap in completeness.

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

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

Schema description coverage is 100% for both parameters ('limit' and 'cursor'), so the schema fully documents them. The description adds no additional parameter semantics beyond what the schema already provides, keeping the score at the baseline for high coverage.

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

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

The description clearly states the tool lists registered users, with a specific verb ('List'), resource ('users'), and scope ('in the n8n instance'). It naturally distinguishes from sibling 'get_user' by indicating a collection-level 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 this tool versus alternatives like 'get_user' or other list tools. There is no mention of filtering options, exclusions, or scenarios where a different tool would be more 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?

The annotation readOnlyHint already signals a safe read operation, and the description's 'List' aligns with that. However, the description adds no behavioral context beyond the annotation—such as pagination, ordering, or response format. It merely restates the tool's name in sentence form, providing minimal additional transparency.

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

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

The description is a single, front-loaded sentence with no wasted words. It immediately states the action and the resource, making it highly concise and scannable. No unnecessary details or fluff.

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

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

For a simple read-only listing tool with two optional parameters, the description is reasonably complete. However, there is no output schema, and the description doesn't mention expected response structure or pagination behavior, which could leave the agent uncertain about what to expect. It's 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?

The schema describes both parameters (limit and cursor) with meaningful descriptions, achieving 100% coverage. The description itself adds no extra parameter-level information, so a baseline score of 3 is appropriate. It doesn't need to compensate for missing schema details.

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

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

The description clearly states the tool's function: 'List n8n environment/instance variables.' The verb 'List' and the specific resource 'n8n environment/instance variables' distinguish it from sibling list tools such as list_workflows and list_credentials. No ambiguity about what the tool does.

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

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

The description doesn't provide explicit guidance on when to use this tool versus alternatives. It is the only tool for listing variables, so usage is implied, but there's no mention of pagination behavior or when to use the 'cursor' parameter. The use case is clear but not elaborated.

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

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

The description adds useful behavior context by mentioning 'Returns node counts and metadata.' With readOnlyHint already present, the safety profile is covered. However, 'List all workflows' overstates the response, as the schema includes a limit (default 50) and cursor, indicating pagination. The description does not disclose that the first call returns a page, not literally all workflows.

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

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

The description is a single, tightly packed sentence, front-loaded with the action and resource. No wasted words; every component (filters, return metadata) earns its place.

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

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

The description is generally adequate for a simple list tool, but it leaves a notable gap: pagination behavior. Without an output schema, the agent must infer pagination from the schema's cursor/limit parameters, and 'all workflows' is misleading. It could be more complete by stating that results are paginated.

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

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

Schema description coverage is 100%, so all parameters are already well-defined. The description merely restates what the schema conveys (filtering by active status, tags, or name) without adding syntactic detail or clarifying cursor behavior beyond the schema. Baseline 3 applies.

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

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

The description uses a specific verb ('List') with a clear resource ('workflows') and scope ('all'), and enumerates filtering criteria. It distinguishes this tool from siblings like get_workflow (single) and create/update/delete mutations.

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

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

The description implies when to use the tool (when needing to list workflows with filters) and provides clear context. However, it does not explicitly call out alternatives like 'use get_workflow for a single workflow' or list exclusionary scenarios, so it misses the top score.

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 only indicate readOnlyHint=false, so the description carries the burden of explaining behavioral impact. It does not disclose side effects, whether a new execution is created, or any required permissions, providing minimal transparency.

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

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

The description is a single sentence that front-loads the action and includes no redundant wording. It is concise and well-structured for a simple tool.

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?

Without an output schema, the description should clarify return values and post-conditions, but it does not. As a mutation tool with minimal annotations, this leaves the agent without critical 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 100%, with both parameters already documented in the schema. The tool description adds no parameter-specific meaning, so the baseline score of 3 is appropriate.

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

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

The description uses the verb 'Retry' with the resource 'execution' and specifies 'using the workflow definition', which clearly distinguishes it from sibling tools like run_workflow or stop_execution. It is specific and unambiguous about what the tool does.

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

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

The description provides no when-to-use or when-not-to-use guidance. It states it retries failed executions but does not mention alternatives or prerequisites, leaving the agent to infer usage from the word 'failed'.

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 readOnlyHint=false annotation already signals a mutating operation, and the description adds no further behavioral context such as asynchronicity, return format, or prerequisites (e.g., workflow must be active). There is no contradiction, but the description is thin on behavioral disclosure.

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

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

The description is a single sentence that is succinct, front-loaded, and free of filler. It conveys the essential action and payload option without unnecessary words.

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

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

The tool has no output schema and minimal annotations, yet the description does not hint at what the execution returns (e.g., an execution ID) or whether the run is asynchronous. This leaves the agent uncertain about the outcome and any prerequisites, making the description incomplete for effective usage.

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

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

The schema already covers both parameters (id and data) with clear descriptions, so the description's mention of 'optional payload data' adds no new semantic detail. Schema coverage is 100%, so a baseline of 3 is appropriate.

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

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

The description uses the verb 'trigger' and clearly identifies the resource as 'workflow execution', also mentioning optional payload data. This distinguishes it from siblings like create_workflow and retry_execution, though it doesn't explicitly state that it operates on an existing workflow by ID.

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

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

The description provides no guidance on when to use this tool versus alternatives such as retry_execution or stop_execution. It simply states the action without contextual cues or exclusions, leaving the agent to infer usage 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 declare destructiveHint=true and readOnlyHint=false, which the description aligns with. The description adds the 'currently running' scope but does not disclose consequences such as irreversibility, effect on related data, or error behavior.

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

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

The description is a single concise sentence that directly conveys the purpose without filler. It appropriately matches the tool's simplicity and is front-loaded with the action.

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

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

For a simple tool with one parameter, full schema coverage, and annotations, the description covers the core action. However, it does not explain return values or post-conditions, leaving some ambiguity about what happens after the stop/cancel is issued.

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

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

The input schema covers 100% of the parameter description, including 'Running execution ID to stop/cancel'. The tool description adds no additional parameter information beyond what the schema already provides.

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

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

The description uses specific verbs 'Stop or cancel' and identifies the resource as 'a currently running execution', clearly conveying the tool's function. It is distinct from sibling tools like list_executions or get_execution, though it does not explicitly name alternatives.

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

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

The description implies that the tool is for running executions, but it does not provide explicit guidance on when to use it versus alternatives like delete_execution or retry_execution. It lacks conditions, prerequisites, or exclusions.

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

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

Annotations already mark it as read-only, and the description adds value by specifying that the connection test verifies API key and response latency. This goes beyond the basic readOnlyHint, providing useful behavioral detail without contradicting the annotation.

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

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

The description is a single sentence, front-loaded with 'Health check:', and every word contributes to understanding the tool's purpose. No fluff or redundancy.

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

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

For a zero-parameter tool with no output schema, the description sufficiently explains the tool's purpose and checks. It could mention the return format or behavior on failure, but that is not critical for a health check.

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 zero parameters and 100% schema coverage (empty schema), the description has no need to explain parameter semantics. Per the rubric, 0 params earns a baseline of 4.

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

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

The description uses a specific verb 'test' and clearly identifies the resource 'connection to n8n instance', while adding the specific checks (API key and response latency). This distinguishes it from all sibling tools, none of which are health checks.

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 prefix 'Health check' implies when to use this tool, and it is unique among siblings, but there is no explicit guidance on when to use it vs alternatives or any exclusions. It's adequate but lacks direct 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?

The description adds no behavioral context beyond the annotations. The 'readOnlyHint: false' and 'idempotentHint: true' annotations already indicate mutation and idempotency, but the description does not disclose details like whether the update is partial or full, what fields are updatable, or any side effects.

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

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

The description is a single, concise sentence with no fluff. It is front-loaded with the verb 'Update' and clearly states the resource. While it is minimal, it is not under-specified to the point of being tautological, so it earns a 4.

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

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

Despite having a nested 'data' object and 4 parameters, the description provides no additional context about behavior, return values, or edge cases. It does not explain how the update is applied (e.g., merge vs replace) or any constraints. The agent must infer everything 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?

Schema description coverage is 100%, so the schema already fully documents all 4 parameters. The description adds no parameter-specific meaning, so it receives the baseline score of 3.

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

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

The description clearly states the tool's purpose with a specific verb ('Update') and resource ('an existing credential'). It distinguishes itself from sibling tools like 'create_credential' and 'delete_credential' by explicitly targeting existing credentials.

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

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

The description provides no guidance on when to use this tool versus alternatives. There is no mention of prerequisites, scenarios, or exclusion of other tools like 'create_credential' or 'delete_credential'. The only implied usage is from the name 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 indicate readOnlyHint=false and idempotentHint=true, covering the mutation and idempotency profile. The description adds no additional behavioral context, such as side effects or prerequisites beyond 'existing tag'. Since the description doesn't contradict annotations and the bar is lower with annotations, a neutral 3 is appropriate.

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

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

The description is a single, concise sentence that front-loads the key information. Every word earns its place, with no redundancy or extraneous detail.

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

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

Given the tool's simplicity (2 required, well-described params, no output schema, and annotations), the description is adequate for an agent to invoke it correctly. It does not explain return values, but for a simple rename operation this is not critical. It might benefit from a note about idempotency, but that is already in annotations.

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

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

Schema description coverage is 100%, with 'id' and 'name' clearly described. The description adds no extra parameter details beyond the schema, but it does reinforce that the tag is existing and the name is new. The baseline is 3 for full schema coverage, with minimal extra value.

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

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

The description 'Rename an existing tag' uses a specific verb ('rename') and resource ('tag'), clearly distinguishing it from sibling tools like create_tag, delete_tag, and list_tags. It unambiguously states what the tool does.

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

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

The description implies usage (when you want to rename a tag) but provides no explicit guidance on when to use this vs alternatives. It does not mention that create_tag should be used for new tags or delete_tag for removal, so the agent must infer from 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 indicate a write operation (readOnlyHint=false) and idempotency (idempotentHint=true). The description adds no additional behavioral context beyond the basic update action, such as error handling or side effects.

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

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

The description is a single, concise sentence packed with essential meaning. It is front-loaded and contains no unnecessary words.

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

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

For a simple CRUD update tool with full schema coverage and annotations, the description is adequate. It could mention error cases or the required id, but overall it provides enough context.

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

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

Schema coverage is 100% with descriptions for id, key, and value. The description's mention of 'key or value' adds minimal value beyond the schema, so baseline 3 is appropriate.

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

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

The description clearly states the verb 'update' and the resource 'variable', and specifies what can be updated (key or value). This distinguishes it from sibling tools like create_variable and delete_variable.

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 conveys that this tool is for existing variables ('an existing variable'), implying it should not be used for creation. However, it does not explicitly name alternatives or provide when-not-to-use guidance.

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

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

The annotations already indicate mutation (readOnlyHint=false) and idempotency (idempotentHint=true), but the description adds no extra behavioral context. It does not state that nodes/connections are replaced, settings are merged, or that only provided fields are updated—all crucial for a 7-field update tool. This leaves the agent unaware of side effects.

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

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

The description is a single, front-loaded sentence that lists the fields without redundant words. It is concise and to the point, effectively summarizing the tool's purpose in 14 words.

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

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

Given 7 parameters, nested objects, and no output schema, the description is too sparse. It omits critical behaviors like merge-versus-replace semantics, partial update behavior, and any response details. This is insufficient for an AI agent to safely invoke the tool with full understanding.

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

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

The input schema has 100% description coverage, so parameters are already well-documented (e.g., 'Replace all nodes', 'Update settings (merged)'). The description simply lists field names without adding any extra semantics, matching the baseline for high schema coverage.

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

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

The description uses the specific verb 'update' with the target resource 'workflow' and enumerates the exact fields (name, nodes, connections, settings, tags, active status), making its purpose clear and distinguishing it from create/delete/get operations. Although there are specialized activate/deactivate tools, the field list covers their scope, so it's unambiguous what this tool does overall.

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

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

The phrase 'existing workflow' clearly signals that this tool is for modifying an already created workflow, implying it should not be used for creation or retrieval. However, it does not explicitly mention alternatives like activate_workflow/deactivate_workflow for status-only changes, so it lacks explicit when-not-to-use guidance.

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