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

No annotations are provided, so the description carries the behavioral disclosure burden. It does state the key consequence—the workflow will begin receiving triggers—but it does not mention idempotncy, errors for already-active workflows, or what the call returns.

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

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

A single, front-loaded sentence states the action and its consequence with no wasted words. It is appropriately sized for a one-parameter 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 low-complexity activation tool with one fully documented parameter, the description plus schema covers the action, target, and effect. It leaves some operational details implicit, such as return behavior and idempotency, but these are minor for this tool.

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

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

Schema description coverage is 100% and the id parameter is documented as 'Workflow ID to activate'. The description does not need to add parameter detail and does not go 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 uses a specific verb ('Activate') and resource ('workflow'), then states the intended effect ('to start receiving triggers'). That clearly distinguishes it from the sibling deactivate workflow tool.

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

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

The phrase 'to start receiving triggers' gives clear context for when this tool is appropriate. It does not explicitly name alternatives or exclusions, but for a simple state-transition tool the intended use is 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?

No annotations are provided, so the description carries the full burden. It only says 'Add a user to a project with a specific role' and does not disclose what happens if the user already belongs to the project, whether roles are overwritten, whether it is idempotent, or what the response contains.

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

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

The description is a single focused sentence with no filler. It leads with the action and includes the essential qualifier about roles.

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 operation is simple and all three required parameters are documented in the schema. However, with no annotations, no output schema, and no mention of valid role values or edge-case behavior, the description is only minimally viable for correct invocation.

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

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

Schema description coverage is 100%, so each parameter already has a basic description. The tool description adds no meaningful parameter semantics beyond 'specific role', and valid role values are not specified even though there are no enums.

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

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

The description states a clear action ('Add a user to a project') and a key qualifier ('with a specific role'). This distinguishes it from remove/change operations at a basic level, though it does not explicitly contrast with sibling tools like n8n_change_user_project_role.

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 n8n_change_user_project_role or n8n_remove_user_from_project. The description implies the use case but gives no exclusions, prerequisites, or alternative routing.

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

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

No annotations exist, so the description carries the full burden. It discloses that fixes are 'safe mechanical', that preview is the default, and that applying takes a snapshot first, which provides reversibility context. It could mention permission requirements or what happens if the workflow is invalid, but the disclosed behavior is substantial for this 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?

Two compact sentences with no filler. The first sentence front-loads the tool's purpose, and the second covers the crucial default and save behavior. Every phrase earns its place.

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

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

For a 2-parameter tool with no output schema, the description is mostly complete: it tells the agent what fixes are applied and how the apply flag changes behavior. A minor gap is that it doesn't specify what the preview output contains (e.g., list of changes), but that is not essential for invoking the tool correctly.

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

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

Schema description coverage is 100% for both parameters, but the description adds practical meaning beyond the schema: it frames id as the target workflow and explains the apply parameter's preview/save effect and snapshot guarantee. This is more than the baseline 3 for full schema coverage.

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

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

The description uses a specific verb ('Apply safe mechanical fixes') and names the workflow as the resource, then enumerates the exact fix categories (missing typeVersion, positions, duplicate node names, dangling connections, missing '=' prefixes). This clearly distinguishes it from sibling tools like n8n_validate_workflow or n8n_update_workflow, which validate or update without the same autofix purpose.

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

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

The description states the default preview behavior and explains when to set apply=true, giving concrete usage context. However, it does not explicitly contrast this tool with alternatives such as n8n_validate_workflow or n8n_update_workflow, leaving the agent to infer that autofix is for mechanical cleanup rather than validation or manual editing.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the core effect and does not mention permissions, prerequisites, reversibility, error conditions, or side effects of changing a user's project role.

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 the action and scope front-loaded. It has no filler, though it is terse enough that more behavioral context could have been added without hurting conciseness.

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

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

For a simple three-parameter mutation tool, the description covers the core purpose but leaves out important context such as valid role values, user membership requirements, and permission needs. With no annotations and no output schema, this is adequate but not complete.

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

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

Schema description coverage is 100%, so the schema already explains each parameter at a basic level. The tool description adds no additional meaning about parameter values, especially the valid role values, which are not enumerated.

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 ('Change') and resource ('user's role within a project'), making the operation clear. It also distinguishes itself from the sibling tool n8n_change_user_role by scoping the change to a project context.

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

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

The phrase 'within a project' clearly indicates when this tool is relevant, separating it from global role changes. However, it does not explicitly mention alternatives or when not to use the tool, so it stops short of full guidance.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Change' implies a mutation, but nothing is said about whether the operation is reversible, what permissions are required, or what side effects occur. For a mutating action with zero annotation coverage, this is a notable gap.

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

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

The description is a single, front-loaded sentence with no filler. It states exactly what the tool does and includes the key scoping term 'global,' making it appropriately concise and efficient.

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

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

For a simple two-parameter mutation with 100% schema coverage and no output schema, the description gives enough to understand the tool's core purpose and differentiate it from the project-role variant. The missing permissions and side-effect context slightly reduce completeness, but the low complexity and rich schema keep it largely 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?

Schema description coverage is 100%, so the input schema already documents both parameters ('User ID' and 'New role') and the role enum values. The description adds no extra meaning beyond the schema, which aligns with the baseline of 3 for full schema coverage.

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

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

The description uses a specific verb ('Change') and resource ('a user's global role'), and the adjective 'global' clearly distinguishes this tool from the sibling n8n_change_user_project_role. An agent can identify what this tool does and what it does not do without opening the schema.

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

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

The word 'global' implies this is for changing global roles as opposed to project roles, which provides some usage context relative to the sibling tool. However, there is no explicit statement of when to use this tool versus alternatives, nor any mention of prerequisites or permission requirements.

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

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

With no annotations, the description must disclose behavioral traits itself; it only states 'Create a new credential', implying it adds rather than overwrites. It does not disclose whether a duplicate name is rejected, what data shape is required for a given type, project scoping behavior, or whether the credential is usable immediately.

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 containing exactly the essential action and object, front-loaded with the verb. No filler 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?

For a tool with a free-form nested object (data), no output schema, and no annotations, this one-sentence description leaves agents without guidance on how to construct valid data or what to expect in return. It doesn't mention consulting get_credential_schema or the required data structure for each credential type.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters. The description's 'specific node type' loosely points at the 'type' parameter but adds no meaning beyond the schema, which includes the httpBasicAuth example. 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 the specific verb 'Create' and identifies the resource as 'a new credential', which clearly distinguishes it from sibling operations like delete, transfer, or get schema. However, 'for a specific node type' is imprecise — the schema shows the type is a credential type like 'httpBasicAuth', not a node type. It doesn't name sibling tools to further disambiguate.

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, what prerequisites exist (e.g., obtaining the credential schema via n8n_get_credential_schema), or how it relates to credential deletion/transfer siblings. The only inference is that it is the creation counterpart, which is self-evident from the name and description.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It only states that a new project is created, without mentioning permissions, uniqueness constraints, default behavior for the optional 'type' parameter, or any side effects. This is thin for a mutating operation.

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

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

A single clear sentence with no filler or redundant content. It is appropriately concise and front-loaded, but it does not go beyond the bare statement of purpose, so it falls short of a 5.

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

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

For a low-complexity create tool with full schema coverage, an agent can form a valid invocation using the required 'name' parameter. However, the lack of any behavioral or permission context, combined with no output schema, leaves the definition slightly under-specified for confident autonomous use.

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

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

Schema description coverage is 100%, with both 'name' and 'type' already documented in the input schema. The description adds no additional parameter context, 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?

States a specific verb ('Create') and resource ('a new project in n8n'), making its core function immediately clear. It distinguishes itself from sibling project tools like update/delete/list, though it offers no detail about project types or scope beyond the schema.

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

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

Provides no guidance on when to use this tool versus alternatives such as n8n_update_project or n8n_delete_project. The intended usage is only implied by the verb 'create' and the tool name; no exclusions or contextual triggers are given.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states that a tag is created, but omits side effects, uniqueness constraints, error behavior, permissions, or return value. 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, focused sentence with no filler or redundancy. It conveys the essential purpose immediately and does not waste any tokens.

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 create operation with one parameter this is minimally usable, but the lack of annotations and output schema means the description should provide more context about expected behavior, such as whether duplicate names are rejected or what response to expect. The current description leaves too much unknown.

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 single parameter 'name' already has a description ('Tag name') in the schema. The tool description does not add meaningful parameter detail beyond what the schema provides, 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 uses a specific verb ('Create'), names the resource ('a new tag'), and adds context ('for organizing workflows'). It clearly distinguishes itself from sibling tag tools like n8n_list_tags, n8n_update_tag, or n8n_delete_tag because it states the action is creation of a brand-new 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?

The description does not provide any guidance on when to use this tool versus alternatives. While the intent to create a tag is clear, there is no mention of when not to use it, whether to reuse existing tags, or any relationship to tools like n8n_update_tag or n8n_list_tags.

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

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

With no annotations, the description carries the full burden of disclosing behavior, but it only repeats the core operation. It does not explain permissions required, failure semantics for partially invalid batches, duplicate email handling, idempotency, or what happens after creation.

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

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

The description is a single, front-loaded sentence with no filler or redundant detail. Every word contributes to identifying the tool's function.

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

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

This is a bulk mutation tool with no output schema and no annotations, yet the description does not mention return behavior, error conditions, permission requirements, or whether creation is all-or-nothing. An agent has enough schema information to build the request body but not enough contextual information to anticipate tool behavior or handle failures correctly.

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

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

The input schema already documents the 'users' array and each user object field, including required 'email' and the role enum (global:owner, global:admin, global:member). The description adds no parameter-level meaning beyond what the schema provides, so the schema-coverage 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 states a specific action ('Create') and a specific resource ('multiple users'), which clearly identifies what the tool does. The bulk nature ('at once') and the contrast with sibling tools like n8n_list_users, n8n_get_user, and n8n_delete_user make its purpose unambiguous.

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

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

The description implies the tool is for creating users, but it provides no explicit guidance on when to prefer it over alternatives or when not to use it. There is no mention of conditions, prerequisites, or exclusions, so usage context is only implicit.

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

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

No annotations are provided, so the description carries the full behavioral burden. It only says the tool creates a variable; it does not disclose side effects, project scope implications, uniqueness constraints, or whether existing variables are overwritten.

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 wasted words. The core purpose is front-loaded and immediately actionable.

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 annotations and no output schema, the description is too thin to fully support a correct invocation. It leaves open questions about the type/value relationship, whether projectId is needed, and what the API returns, especially given the additional schema parameters.

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 description adds no parameter-level meaning beyond the input schema, but the schema itself includes brief descriptions and an enum for type, giving high coverage. The description does not compensate for any ambiguity, so the baseline of 3 is appropriate.

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

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

The description states a specific verb ('Create') and a clear resource ('environment variable'), which distinguishes this tool from list, update, and delete variable siblings. Even without referencing the siblings, the main action and focus are unambiguous.

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

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

There is no guidance on when to use this tool versus alternatives like n8n_update_variable or n8n_delete_variable. The agent must infer usage from the tool name alone, and no preconditions 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does convey that valid JSON input is a precondition (implied by the validate-first instruction) and names the configurable surface. However, it omits post-creation behavior: whether the workflow starts active or inactive, whether a created workflow object/ID is returned, and any error semantics. Core behavior is clear but creation outcomes are undisclosed.

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

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

Three short sentences, front-loaded with the core purpose, with zero filler. The validation-sequencing sentence earns its place by preventing broken submissions, and the specifiable-fields sentence is compact. The description is appropriately sized for the tool's moderate complexity.

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 detailed schema covers the nested node structure, and the description covers creation intent plus the search/validate pre-workflow. Missing pieces are what happens on success (returned object/ID) and the default state of a created workflow, both relevant when an agent chains subsequent calls — and there is no output schema to fill that gap. Adequate, but with clear gaps.

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

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

Schema coverage is 100%, so all four parameters (name, nodes, settings, connections) are already documented in the input schema. The sentence 'You can specify nodes, connections, and settings' largely restates schema properties and adds only marginal emphasis. Per the baseline rule for high schema coverage, a 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 opens with a specific verb+resource ('Create a new workflow in n8n') and expands scope by naming what can be specified (nodes, connections, settings), making clear this is a from-scratch construction rather than a template-based or update operation. However, it doesn't explicitly differentiate from sibling creation paths like n8n_create_workflow_from_template or n8n_import_workflows, so it stops short of full sibling distinction.

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

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

Provides explicit sequencing guidance: 'Prefer n8n_search_nodes + n8n_validate_workflow first so the JSON is valid.' This concretely tells the agent which companion tools to run before invoking this one, which is actionable and specific. It does not state exclusion criteria versus alternatives (e.g., when to choose create_workflow_from_template instead), so it lacks the when-not dimension that would earn a 5.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, but it only states creation and automatic template selection. It does not mention activation defaults, error/fallback behavior if no template matches, side effects, or whether the workflow is created inactive.

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

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

The description is two short sentences with no filler. It front-loads the core action and uses the second sentence to add a key behavioral detail, so every word earns its place.

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

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

For a creating tool with no annotations and no output schema, this description is incomplete. It does not state what is returned, what happens when neither templateId nor userRequest is provided, how conflicts are resolved, or which sibling tools should be used to discover templates first.

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 four parameters are already well documented. The description adds a small amount of context about automatically selecting the best template when templateId is not provided, but it does not add meaningful detail beyond the schema.

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

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

The description clearly states the action ('Create a new workflow in n8n') and the resource ('based on a template'), and it adds the distinguishing auto-selection behavior. However, it does not explicitly differentiate this from sibling tools like n8n_create_workflow or n8n_import_public_template.

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

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

There is no explicit guidance on when to use this tool versus alternatives, nor any exclusions or prerequisites. The template-based creation use case is implied, but the description leaves the agent to infer when this is preferable to n8n_create_workflow or n8n_import_public_template.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It clearly states that deactivation stops triggers, which is the core side effect. However, it does not mention whether deactivation is reversible, whether in-flight executions are affected, or any permission requirements.

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

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

The description is a single, focused sentence that front-loads the action and its purpose. Every word adds value, with no redundant or filler content.

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

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

For a simple one-parameter state-change tool, the description plus schema is largely complete: the agent knows what to call, what parameter to provide, and what effect to expect. Minor gaps include reversibility and edge cases, but these are not critical for basic invocation.

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

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

Schema description coverage is 100%, and the single 'id' parameter is already well-documented as 'Workflow ID to deactivate.' The description adds no further parameter-level detail, 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 ('deactivate') and a clear resource ('workflow'), and explicitly states the intended effect: 'to stop receiving triggers.' This clearly distinguishes it from siblings like n8n_activate_workflow and n8n_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 phrase 'to stop receiving triggers' gives clear contextual guidance for when to use this tool. It does not explicitly name alternatives or exclusions, but the intended use case is obvious and it pairs naturally with n8n_activate_workflow.

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

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

Annotations already declare readOnlyHint: true, so the safety profile is covered. The description adds some context about what is returned (failing node and error message) but does not disclose additional behavioral details such as response format or edge cases. It also does not contradict the annotations.

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

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

The description is two concise sentences with no redundant wording. The core functionality is front-loaded, followed by a useful usage directive. Every sentence contributes value.

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

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

For a simple read-only diagnostic tool with one optional parameter and no output schema, the description covers what it does, what it returns, and when to use it. Nothing essential is missing for an agent to invoke it correctly.

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

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

Schema description coverage is 100% for the single optional workflowId parameter. The description restates that the workflow is optional ('optionally for one workflow'), which aligns with the schema but adds little beyond it. The baseline of 3 is appropriate because the schema carries the parameter meaning.

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

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

The description states a specific verb and resource: 'Get the most recent failed execution' with the failing node and error message. This clearly distinguishes it from related execution tools like n8n_list_executions and n8n_get_execution by focusing on the most recent failure.

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

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

It gives clear usage context: 'Use this to repair a broken workflow.' It does not explicitly mention alternatives or when not to use it, but the intended scenario is clear and actionable.

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 destructiveHint annotation already flags the destructive nature, and the description adds the authorization requirement ('owner only'). It does not mention irreversibility or impact on workflows using the credential, but the annotation lowers the burden and the added auth context is valuable.

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 wasted words. The core operation is front-loaded, and the permission qualifier is placed compactly in parentheses.

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

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

For a one-parameter delete operation with a destructiveHint annotation, the description covers the essential context: what is deleted and under what authorization. It could mention permanence or downstream effects, but these are not critical for invoking the tool correctly.

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

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

Schema coverage is 100%, with the 'id' parameter already described as 'Credential ID to delete'. The tool description adds no extra semantic detail about the parameter beyond what the schema already provides, so the baseline score of 3 is appropriate.

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

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

The description states the exact operation and resource: 'Delete a credential'. The 'owner only' qualifier adds a scoping constraint that clarifies who can perform the deletion. This clearly distinguishes it from credential-related siblings like create, transfer, or schema retrieval.

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 use when a credential needs to be removed and communicates the owner-only restriction. It does not explicitly discuss alternatives or when not to use it, but for a delete operation this context is largely sufficient.

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 merely restates the tool's function without adding behavioral context beyond the annotations. The destructiveHint annotation already signals that deletion is destructive; the description does not mention permanence, permissions, side effects, or any additional caveats.

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

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

The description is a single, front-loaded sentence with no filler. It conveys the essential purpose in five words and earns its place.

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

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

For a one-parameter mutation tool with destructiveHint annotation and no output schema, the description covers the core action and resource sufficiently. It lacks finer details like irreversibility or error behavior, but these are largely implied by the word 'delete' and the annotation, making it 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 fully documents the sole parameter 'id' with its type and description, so the description adds no parameter semantics. Schema coverage is 100%, 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 'Delete an execution record' names a specific verb (delete) and resource (execution record), clearly stating what the tool does. It distinguishes itself from sibling tools like n8n_get_execution, n8n_retry_execution, and n8n_list_executions, being the only execution deletion tool.

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

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

No guidance is provided on when to use this tool versus alternatives such as n8n_retry_execution or n8n_delete_workflow. The description does not state any prerequisites, reversibility, or conditions for use.

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

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

The description merely states 'Delete a project' and adds nothing beyond the destructiveHint annotation. It does not disclose irreversibility, cascading effects on associated workflows or credentials, or permission requirements, so an agent has no behavioral detail beyond the structured hint.

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

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

The description is a single, focused sentence with no filler or repetition, which is structurally clean. However, it is so terse that it contributes almost no information beyond the tool name, so it is efficient but not richly written.

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

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

For a one-parameter, destructive operation with no output schema, the bare description plus input schema is minimally workable: an agent can infer the call shape. It lacks usage guidance and any statement of consequences or required permissions, so it is not fully 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 description covers the only parameter at 100% ('Project ID to delete'), so the description does not need to explain it. The tool description adds no extra parameter semantics, but the schema's coverage supports 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 names a specific verb ('Delete') and resource ('project'), which is unambiguous and distinguishes it from sibling delete operations on workflows, credentials, executions, tags, variables, and users. It is clear, though it adds no detail beyond what the tool's name already conveys.

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

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

There is no guidance about when to call this tool instead of e.g. n8n_update_project or n8n_list_projects, nor any prerequisites or alternatives. The only usage signal is the required id parameter in the schema, which is not guidance in the description.

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

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

The description adds no behavioral detail beyond the destructiveHint annotation; it simply restates the delete action. It does not mention whether deletion is permanent, affects workflows using the tag, or how errors are handled. It does not contradict the annotations, but provides no 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, direct sentence with no unnecessary wording. It is front-loaded and easy to parse, which is ideal for a simple tool definition.

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

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

For a one-parameter delete tool with a clear schema and destructiveHint annotation, the description is nearly complete. It could mention side effects such as whether the tag is removed from workflows or whether deletion is irreversible, but the core information needed to invoke the tool is present.

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

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

The input schema fully documents the single parameter 'id' as 'Tag ID to delete', so schema coverage is 100%. The description adds no extra parameter semantics, but none are necessary given the schema's clarity.

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

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

The description states the action ('Delete') and resource ('a tag') explicitly, making the tool's purpose immediately obvious. It also distinguishes the tool from sibling tag operations (create, get, list, update) and from deletion tools for other resource types.

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

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

There is no guidance on when to use this tool versus alternatives, nor any mention of prerequisites or conditions that should hold before deletion. The description relies entirely on the verb 'Delete' to imply usage.

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

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

The destructiveHint annotation already signals destructiveness, but the description adds no behavioral context beyond repeating the delete operation. It does not disclose permanence, cascading effects on memberships/projects, or permission requirements, and it does not contradict annotations.

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

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

The description is a single clear sentence with no redundant words or filler. Its brevity is appropriate for a one-parameter 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?

For a low-complexity tool with one parameter and a destructive annotation, this is minimally viable: the agent knows the action, the target, and the danger. Clear gaps remain around irreversibility, permissions, and side effects, which matter for user deletion.

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

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

Schema description coverage is 100%, and the schema already documents 'id' as 'User ID to delete'. The description contributes no additional parameter meaning, so the baseline 3 applies.

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

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

The description states a specific verb ('Delete') and resource ('a user'), distinguishing it from user-query/creation tools and from remove_user_from_project. However, it is a bare paraphrase of the tool name and leaves scope details unstated.

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

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

No when-to-use or when-not-to-use guidance is provided. It does not mention alternatives such as remove_user_from_project or change_user_role, nor how to obtain a user ID via list_users/get_user.

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 destructiveHint annotation already signals that the operation is destructive, and the description specifies which object is destroyed. However, it does not disclose additional behavioral details such as irreversibility, side effects on workflows referencing the variable, or required permissions.

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

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

The description is a single, front-loaded sentence with no wasted words. It conveys the essential operation immediately and is appropriately sized for a tool with one parameter.

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

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

For a simple one-parameter delete operation, the description, schema, and destructiveHint annotation provide enough information to select and invoke the tool correctly. A small gap remains around expected return behavior and post-deletion effects, but these are not critical given the tool's simplicity.

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

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

Schema coverage is 100%: the single required 'id' parameter is described as 'Variable ID to delete.' The description does not add further parameter-level meaning, so the schema carries the burden and 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 action, 'Delete', applied to a specific resource, 'an environment variable.' This unambiguously distinguishes the tool from sibling delete tools such as n8n_delete_workflow and n8n_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 provides no guidance on when to use this tool versus alternatives like n8n_update_variable or n8n_list_variables. It only states the basic operation, leaving the agent to infer the appropriate context.

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

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

The destructiveHint annotation already flags destructive behavior, and the description adds valuable context: the deletion is permanent but a local snapshot is saved first, and restoration goes into a new workflow. This goes beyond what the annotation alone communicates.

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

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

Two short sentences with no filler. The core destructive action is front-loaded, and the recovery note follows immediately, making the description easy to parse in one pass.

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

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

For a one-parameter tool with full schema coverage and a destructiveHint annotation, the description covers the essential behavioral implications: permanence, snapshot safety, and restoration path. Nothing critical is missing for correct invocation.

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

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

The input schema already fully documents the single 'id' parameter with a clear description, and the tool description adds no additional parameter-level meaning. With schema coverage at 100%, 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?

States a specific verb ('Delete'), a specific resource ('workflow'), and a clear modifier ('permanently'). This clearly distinguishes it from sibling tools that create, update, activate, or deactivate workflows.

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

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

The description makes clear this tool is for permanent deletion and explains the recovery path via n8n_rollback_workflow. It does not explicitly contrast with n8n_deactivate_workflow or list when-not-to-use conditions, but the context is clear enough for an agent to select it for a delete intent.

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

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

With readOnlyHint=true already signaling a safe read operation, the description adds useful behavioral context by specifying what the diff reports: changed nodes, parameters, and connections. It aligns with the read-only annotation and gives the agent a clear picture of the tool's non-mutating scope.

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

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

Two tight sentences: the first defines the operation and its scope, the second provides usage context. No filler or redundant restatement of the tool name.

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

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

For a read-only diff tool with well-documented parameters, the description is largely complete. It names the comparison dimensions even without an output schema, so an agent can anticipate the kind of result. Minor gap: the exact return format is not described, but this is not critical for selecting and invoking the tool.

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

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

Schema description coverage is 100%, and the parameter descriptions already explain id, to, and from with defaults. The description adds little beyond what the schema states, so the baseline of 3 is appropriate.

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

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

The description opens with a specific verb, 'Compare', and names the exact resources: a workflow snapshot versus the current state or another snapshot. It enumerates what the comparison covers (nodes added/removed/modified, changed parameters, connection changes), making it easy to distinguish from sibling tools like n8n_list_workflow_snapshots or n8n_rollback_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 gives a clear use context: 'Useful before deciding whether to roll back.' This implicitly positions it as a decision-support tool rather than a mutation tool, though it does not explicitly name alternatives or when-not-to-use conditions.

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

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

Annotations already declare readOnlyHint=true, and the description adds that the tool reads all workflows and writes JSON files locally. It does not disclose directory creation behavior, overwrite semantics, or success/confirmation details, so it adds only modest behavioral context 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 two tight sentences with no filler. The action and output format are front-loaded, and the second sentence earns its place by clarifying the tool's relationship to snapshots.

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 zero required parameters, one optional directory parameter, and read-only annotation, the description covers scope, destination, and relationship to existing backups. It does not explicitly describe return/confirmation behavior, but that is a minor gap given the low complexity and absent output schema.

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

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

Schema description coverage is 100%, and the single directory parameter is already fully documented with its default path. The description's phrase 'local directory' aligns with the schema but adds no additional parameter-level meaning.

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

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

The description states a specific verb ('Back up'), resource ('every workflow of the instance'), and output form ('individual JSON files in a local directory'). It also distinguishes itself from per-change snapshots, making its purpose unambiguous even among many sibling tools.

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

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

The description gives clear context by positioning the tool as a full-instance safety net that complements per-change snapshots. It does not explicitly list alternatives or exclusions, but the intended use case is clear enough for an agent to decide when to invoke it.

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 readOnlyHint=true, and the description adds no behavioral context beyond that—no mention of what the report covers, how it is generated, or what the agent should expect. It does not contradict the annotation, but it also does not go beyond it.

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

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

The description is a single, front-loaded sentence with no filler. It is appropriately concise for a tool with no parameters and no configuration surface.

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

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

For a read-only, parameterless tool, the description is minimally adequate, but it omits what the audit report contains and what the return value looks like. Since there is no output schema, an agent would benefit from more detail about the report's scope or format.

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

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

The tool has zero parameters, so the input schema is already complete and there is nothing for the description to add. The 0-parameter baseline of 4 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 ('Generate') and a specific resource ('security audit report'), making the tool's purpose immediately clear. No sibling tool has the same purpose, so it is easily distinguishable.

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 intended use is implied by the phrase 'security audit report', but the description gives no explicit guidance about when to use this tool versus alternatives or when not to use it. There is no mention of 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?

Annotations already declare readOnlyHint=true, and the description is consistent with that by using 'Get'. The description adds no meaningful behavioral detail beyond what the annotations and tool name convey, such as return format, error behavior for unknown credential types, or whether authentication is required.

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

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

The description is a single, front-loaded sentence with no filler. Every word contributes to explaining the tool's purpose and intended use.

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

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

This is a simple, read-only lookup tool with one required parameter and no nested objects. The description is adequate for understanding the basic purpose and expected input, though it does not describe the shape of the returned schema or what happens when an unknown credential type name is supplied.

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

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

The schema describes the only parameter, credentialTypeName, as 'Credential type name', and the description repeats this concept. With 100% schema description coverage, the description does not need to add much, but it also provides no extra guidance on where to find valid credential type names or what format is expected.

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

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

The description states a specific action ('Get the schema') on a specific resource ('a credential type') and explains the purpose ('understand required fields'). It clearly distinguishes this from sibling tools like n8n_create_credential and n8n_delete_credential by focusing on schema retrieval rather than credential lifecycle operations.

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

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

The phrase 'to understand required fields' implies this should be used before creating or editing a credential, but there is no explicit guidance on when to use this tool versus alternatives, nor any mention of prerequisites like needing a valid credential type name. The usage context is only implied.

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

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

readOnlyHint=true already communicates that this is a safe read operation, and the description's 'Get' is consistent with that annotation. The description adds little behavioral context beyond the word 'detailed', so this is minimally transparent but not contraddictory.

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

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

It is a single, front-loaded sentence that states the action and target immediately. There is no redundant wording 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 read-only getter with one required parameter and one boolean flag, the description plus the schema is mostly sufficient. It could be slightly more explicit about what 'detailed information' includes or when to choose node-level execution data instead, but no essential calling detail is missing.

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

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

The schema provides complete descriptions for both parameters (id: 'Execution ID', includeData: 'Include execution data'), and the description itself adds no further parameter semantics. With 100% schema coverage, 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 clear action verb ('Get') with a concrete resource ('a specific execution') and says the result is detailed information. This distinguishes it from list, delete, and retry execution tools, so an agent can identify the right sibling without inspecting schemas.

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

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

The description implies this tool is for when an agent has an execution ID and wants more detail than a list view would give. However, it does not explicitly contrast it with siblings like n8n_list_executions or n8n_get_node_execution_data, and there is no when-not guidance.

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

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

Annotations already mark the tool as read-only, and the description adds meaningful detail about the output contents: parameter types, options, display conditions, credentials, latest typeVersion, and curated notes. This goes beyond the schema and annotations, helping the agent anticipate what will be returned.

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

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

The description is a single dense sentence that front-loads the verb and object, then efficiently lists the return contents. Every phrase adds value and there is no filler.

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

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

For a simple read-only lookup with one required parameter and no output schema, the description provides enough detail about what the agent will receive. A minor gap is the lack of explicit behavior for unknown or uncommon node types, but that is not necessary for correct invocation.

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

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

The input schema covers the single parameter completely, including an example of valid aliases ('n8n-nodes-base.slack' or 'webhook'). The description does not add much beyond this, so the baseline of 3 is appropriate.

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

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

The description starts with a specific verb ('Get') and a precise resource ('real parameter schema of an n8n node type'). It enumerates exactly what the result includes: parameters, types, options, display conditions, required params, credentials, typeVersion, notes, and an example. This clearly differentiates it from siblings like n8n_get_credential_schema and n8n_search_nodes.

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

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

The description does not explicitly state when to use this tool versus alternatives. While the purpose is clear, there is no mention of when to prefer it over n8n_get_credential_schema or n8n_search_nodes, and no exclusions or prerequisites are provided.

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

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

With readOnlyHint=true already covering the safety profile, the description adds meaningful behavioral context: it discloses that only a limited sample of output items is returned (not the full data set), and that the return shape varies by mode (status/item counts/errors vs output items/error details). This goes beyond the annotation and helps set agent expectations about data volume and content. No contradiction with annotations.

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

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

Two sentences, no wasted words. The core purpose is front-loaded in the first sentence, and the conditional behavior is packed efficiently into the second. Every clause earns its place.

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

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

For a 3-parameter tool with one behavioral fork, this is complete: the dual-mode behavior is fully explained, the result content of each mode is described, and the schema already covers required parameters, defaults, and bounds. No output schema exists, but the description preemptively describes what each mode returns, so an agent can invoke it correctly without further digging.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value on top by tying parameters to actual outcomes: it explains that omitting nodeName yields an overview of all nodes while providing it yields output items and error details, and reinforces itemsLimit's role via 'limited sample'. This behavioral linkage is genuinely useful beyond the schema's per-field descriptions.

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?

Opens with a specific verb+resource ('Inspect the data that flowed through a specific node in an execution') and immediately differentiates itself from the whole-execution alternative ('without downloading the whole execution'). The dual-mode behavior (overview vs node-specific details) is crisply stated, so an agent knows exactly what the tool does and how it differs from siblings like n8n_get_execution.

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 'without downloading the whole execution' phrase is an implicit exclusion that routes agents to this tool for cheap, targeted inspection rather than fetching an entire execution (e.g., via n8n_get_execution). It also gives clear within-tool mode guidance: omit nodeName for an overview, provide it for detailed output items. It stops short of naming sibling tools explicitly, so it doesn't earn a 5.

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

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

The readOnlyHint annotation already covers the safety profile, and the description is consistent with it. The description adds no behavioral details beyond the annotation, such as return shape, error behavior for nonexistent tags, or permission requirements. Since annotations already declare read-only, this is acceptable but not enriched.

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 with no filler or repetition. It is front-loaded and efficient, conveying the essential purpose immediately.

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

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

For a simple one-parameter read-only lookup, the description, tool name, and schema together provide enough for an agent to select and invoke the tool correctly. The absence of an output schema means the return shape is not detailed, but for such a straightforward get operation this is a minor gap.

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

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

Schema description coverage is 100%, with the single parameter 'id' documented as 'Tag ID.' The description adds no additional semantic detail about the parameter, so the schema carries the meaning; 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 states a clear verb and resource: 'Get information about a specific tag.' The word 'specific' signals a single-tag lookup by ID, which distinguishes it from list-oriented siblings like n8n_list_tags or n8n_get_workflow_tags, though it does not explicitly name those 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?

Usage context is implied rather than stated: an agent can infer this is for fetching one tag when an ID is known, but the description does not explicitly say when to prefer this over n8n_list_tags or when not to use it. There is no mention of 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 signals a safe read operation, and the description adds a useful auth-related behavioral constraint: 'owner only'. This goes beyond the annotation by disclosing a permission requirement, though it does not describe error behavior or response shape.

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 packs the verb, resource, lookup method, and access restriction with no wasted words. It is concise and front-loaded with the most important 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?

This is a simple single-parameter read tool with readOnlyHint true and clear lookup semantics. The description covers the essential details an agent needs to select and invoke it correctly: what it fetches, how to identify the user, and who is allowed to call it.

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

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

The schema already provides 100% description coverage for the single `id` parameter ('User ID or email'). The description essentially repeats this by saying 'by ID or email', adding no new semantic detail beyond what the input schema provides.

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

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

The description states a specific verb ('Get'), a clear resource ('user'), the lookup key ('by ID or email'), and an access constraint ('owner only'). This clearly distinguishes it from siblings like n8n_list_users or n8n_delete_user, so an agent can immediately understand the tool's 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 when to use the tool: for a single-user lookup by ID or email, and it adds the prerequisite that only the owner can call it. However, it does not explicitly name alternatives like n8n_list_users for listing all users or mention when not to use this tool.

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

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

Annotations declare readOnlyHint: true, and the description does not contradict this. However, the description adds no behavioral context beyond the annotation—no mention of what response fields to expect, whether any preconditions exist, or any other side effects. For a read-only getter this is a minor gap, but the description fails to add value beyond the structured 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 one short sentence that contains the essential information: what the tool does and the key selector. There is no filler or unnecessary elaboration, making it easy to parse and remember.

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

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

For a single-parameter getter with an annotation covering read-only behavior, the description is mostly sufficient. However, with no output schema, it would be helpful to clarify what 'detailed information' includes (e.g., nodes, connections, settings). This vagueness leaves some ambiguity for an agent trying to understand the return value.

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% coverage for the single parameter 'id' with the description 'Workflow ID'. The tool description redundantly mentions 'by ID' but adds no new meaning. Since the schema already documents the parameter adequately, this is a baseline score for a well-covered 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 uses a specific verb ('Get') with a clear resource ('detailed information about a specific workflow by ID'). It conveys that this tool retrieves one workflow rather than a list, which helps distinguish it from sibling tools like n8n_list_workflows. However, it does not explicitly name or contrast any sibling, and 'detailed information' is somewhat vague.

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

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

There is no explicit guidance on when to use this tool versus alternatives. The phrase 'specific workflow by ID' weakly implies a use case, but the description never states that n8n_list_workflows or n8n_list_workflows_summary should be used for listing workflows, nor does it mention any exclusions. This leaves the agent to infer routing 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 indicates this is a safe read operation, and the description adds the workflow-scoped nature of the result. It does not disclose response format, behavior for missing workflows, or empty tag lists, but for a simple read-only tool 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 clear sentence with no filler or repetition. It front-loads the action and resource, making it 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?

For a simple one-parameter, read-only tool, the description plus complete schema is nearly sufficient. The return value is inferable from the tool name and description, though explicit details about the output shape or error behavior are not provided.

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 fully describes the single parameter 'id' as a Workflow ID, and the description reinforces that the ID refers to a workflow. No additional syntax, format, or edge-case semantics are provided, so the baseline of 3 is appropriate given 100% schema coverage.

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

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

The description states a specific verb ('Get'), a specific resource ('tags'), and a clear scope ('associated with a workflow'). It distinguishes itself from sibling tools like n8n_get_tag (single tag), n8n_list_tags (global tag list), and n8n_update_workflow_tags (mutation).

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 usage context is implied: use this tool when you need the tags attached to a specific workflow, identified by its ID. However, it does not explicitly state when to prefer this tool over alternatives such as n8n_list_tags or n8n_get_tag, nor does it list 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 covers the safety profile, and the description adds a meaningful behavioral detail: it can match templates intelligently rather than only retrieving by ID. It does not disclose specifics like matching criteria, behavior when both parameters are provided, or possible network/API dependencies, but 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?

A single sentence covers both operation modes with no filler. The primary action is front-loaded, and the alternative path is clearly appended.

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 only two optional parameters, a read-only annotation, and no output schema, the description is mostly complete for an agent to understand the tool's high-level purpose. It could be more complete by stating what the returned template contains or how the intelligent matching behaves, but nothing critical is missing for basic invocation.

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

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

Schema description coverage is 100%, so the schema already documents both parameters adequately. The description adds modest semantic value by linking templateId to the 'by ID' mode and userRequest to the 'intelligent matching' mode, but it does not materially expand on 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 a specific verb ('Get') and resource ('workflow template'), and identifies two operation modes: by ID and by user requirements. It does not explicitly contrast with sibling tools like n8n_list_workflow_templates or n8n_search_public_templates, but the core purpose is unambiguous.

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

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

The description implies when to use each mode: provide templateId when the ID is known, otherwise provide userRequest for intelligent matching. However, it does not explain when to prefer this tool over the overlapping sibling n8n_search_public_templates or n8n_list_workflow_templates, so usage guidance remains implicit rather than explicit.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It states the main side effect (creating a workflow) and adds a meaningful caveat that credentials must still be attached separately. It does not cover activation or duplicate handling, but the core behavioral traits are clear.

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 concise sentences with no filler. The main action is front-loaded, and the credential caveat is placed as a separate, easily digestible sentence.

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

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

The description covers the core import behavior and the credential post-requisite, making it minimally viable. However, with no output schema, no annotations, and two undocumented optional parameters, it leaves the activate flag and workflow naming behavior unexplained.

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

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

Schema coverage is only 33%, so the description needed to explain the remaining parameters. It only reinforces that templateId identifies the template, while activate and workflowName remain semantically unexplained in both the schema and the description.

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

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

The description clearly states the operation: download an official n8n.io template by ID and create it as a workflow in this instance. It distinguishes this from generic workflow creation and read-only template retrieval, though it does not explicitly differentiate it from sibling tools like n8n_create_workflow_from_template.

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 'official n8n.io template' wording implies the intended scope, and the credential note signals a required follow-up step. However, the description does not explicitly say when to choose this tool over alternatives or when not to use it.

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

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

With no annotations provided, the description carries the full behavioral burden. It does disclose a key trait: imported files become new workflows, suggesting non-destructive import rather than overwrite. However, it does not mention permissions, failure behavior, duplicate handling, or whether imported workflows are validated.

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 written sentence with the core action front-loaded. The parenthetical example is useful and does not add bloat. Every phrase 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?

Given the simplicity of the tool and full schema coverage, the description is adequate for basic invocation. However, because there is no output schema and no annotations, it leaves some operational unknowns unaddressed, such as what the tool returns after import and how conflicts are handled.

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

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

Schema coverage is 100%, so the schema already documents both parameters and their meaning. The description adds slight context by mentioning backups and the import direction, but it does not materially improve parameter understanding beyond the schema.

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

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

The description uses a specific verb and resource: importing workflow JSON files from a local directory as new workflows. It also clearly distinguishes this from creating or templating workflows by emphasizing the directory-based, bulk-import nature.

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

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

The description gives a clear contextual example (backups from n8n_export_all_workflows) and implies this is the restoration/import path, but it never explicitly states when to prefer this over n8n_create_workflow or template-based import tools. Usage is implied rather than explicitly routed.

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 that this is a read-only operation. The description adds value by warning that includeData=true significantly increases token usage and recommending fields to reduce tokens, but it does not disclose pagination behavior, result shape, or any other execution-specific behavior beyond the filters.

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

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

Two short sentences with no filler. The core purpose and filters are stated first, followed by a useful, actionable tip about token usage. Every sentence earns its place.

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

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

For a read-only list operation with a fully documented parameter schema, the description covers the essential filters and adds token-usage guidance. It lacks explicit output-format or pagination details, but the cursor parameter and the simple 'list' semantics make this a minor gap rather than a blocking one.

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

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

Schema description coverage is 100%, so every parameter is already documented in the schema. The description's tip about includeData=false and fields adds practical usage guidance but does not explain the parameters themselves beyond what the schema already provides.

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

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

The description uses a specific verb and resource ('List workflow executions') and enumerates the filterable dimensions (status, workflow ID, project). It does not explicitly differentiate itself from sibling n8n_get_execution, but the list-vs-get distinction is clear from the verb and resource name.

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

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

The description implies usage by stating what the tool lists and what filters are available, but it does not explicitly say when to prefer this over n8n_get_execution or related sibling tools. The guidance is adequate but relies on inference.

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

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

The description adds no behavioral context beyond the readOnlyHint annotation. It does not disclose pagination, filtering, permission requirements, or what exactly 'all projects' means (e.g., archived vs. active). Since annotation already declares read-only, the description should add something extra to merit a higher score.

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 filler. It is appropriately sized for a zero-parameter read-only tool. However, it is minimal rather than genuinely informative, so it doesn't earn a 5 for helpfulness.

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, read-only list operation, the description is functionally complete: an agent can invoke it without further clarification. The absence of an output schema is acceptable because the description names the resource type. A 4 reflects that it is sufficient but not enriched with any contextual depth.

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

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

The tool has zero parameters, so the baseline is 4. The description does not need to explain parameters, and 'List all projects' correctly implies there are no configuration options. Nothing is missing on this dimension.

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 projects.' uses a clear verb and resource, so an agent immediately knows what the tool does. It doesn't explicitly differentiate from sibling list tools, but the resource name 'projects' distinguishes it from list_workflows, list_tags, etc. A 5 would require explicit distinction or additional scoping.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention any conditions, prerequisites, or sibling tools that might be more appropriate. The agent is left to infer usage solely from the tool name.

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

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

The annotation readOnlyHint=true already covers the safety profile, and the description does not contradict it. The description adds the behavioral scope that this lists the global tag collection rather than workflow-scoped tags, but it does not disclose response format or pagination. With annotations present, 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, direct sentence that front-loads the action and resource. Every word is functional and there is no unnecessary detail.

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

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

For a zero-parameter, read-only list operation backed by annotations, the description is sufficient for an agent to select and invoke the tool. It does not describe the output shape, but with no output schema and trivial complexity, that omission is minor.

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

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

The tool has zero parameters and the input schema is empty with 100% schema description coverage, so there are no parameters to explain. The baseline of 4 applies because the description has no parameter burden to compensate for.

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

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

The description clearly states the verb 'List' and the resource 'tags' with the scope 'all tags available in n8n', which identifies the tool's purpose. It does not explicitly differentiate from sibling tools like n8n_get_tag or n8n_get_workflow_tags, so it falls just short of full sibling differentiation.

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

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

The description implies the tool should be used when the full set of tags is needed, but provides no explicit usage conditions, exclusions, or alternatives. Given tag-related siblings such as n8n_get_tag and n8n_get_workflow_tags, it misses an opportunity to guide selection between them.

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

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

The readOnlyHint annotation already signals a safe read operation, and the description adds a useful behavioral/access restriction: the operation is owner-only and lists all users rather than a filtered subset. No contradiction with 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 short, front-loaded sentence: 'List all users (owner only).' Every word contributes either the action, the resource, or an important constraint, with no filler or redundancy.

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

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

For a simple, read-only list operation with one optional boolean parameter fully documented in the schema, this description is complete. An agent knows what the tool does, who can use it, what its scope is, and that it is non-mutating.

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

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

The schema covers the only parameter (includeRole) with a clear description ('Include role information'), so baseline is 3. The tool description does not add any further parameter context, but it does not need to given 100% 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 ('List') and resource ('all users'), and adds a clear scoping restriction ('owner only'). This clearly distinguishes it from n8n_get_user (single user) and from the many workflow/credential/tag list tools among its siblings.

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

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

The description does not explicitly state when to choose this tool over alternatives like n8n_get_user, nor does it provide when-not-to-use guidance. The usage is implied by the name and phrasing, but there is no explicit routing to 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 signals that this is a safe read, and the description merely restates 'List' without adding behavioral nuance. It does not disclose whether filters are optional, whether results are paginated, whether variable values are masked, or how project scoping affects the returned set.

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

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

The description is a single front-loaded sentence with zero filler. It states the action and the resource directly 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?

For a simple list operation with two optional filters and a read-only annotation, the description is minimally viable. However, it lacks clarity about how filters interact with 'all', whether project scope is required for viewing variables, and what the return payload contains, especially since no output schema is provided.

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 'state' and 'projectId' described as filters. The description adds no parameter-level meaning beyond what the schema already provides, so the baseline of 3 is appropriate.

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

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

The description states a specific verb ('List') and a concrete resource ('all environment variables'), making the tool's purpose immediately clear. While it does not reference sibling tools, there is no competing 'list variables' option among the siblings; the variable CRUD siblings are clearly different operations.

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

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

The usage is implied: this is the tool to call when you need to retrieve environment variables. However, the description does not explicitly state when not to use it or mention alternatives for variable creation, updates, or deletion, leaving the routing to inference.

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

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

Annotations already declare readOnlyHint=true, and the description adds meaningful behavioral context by warning that the response includes complete workflow data such as nodes and connections, which implies potentially large output. It does not discuss pagination behavior, but the read-only nature is already covered and the payload warning adds real value beyond annotations.

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

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

Two sentences with zero filler. The core function is stated first, then the filters, then the critical warning and alternative. The warning is front-loaded where it can most influence tool selection.

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 seven optional parameters, the description adequately conveys purpose, filters, and the important payload caveat. It lacks explicit mention of pagination or default result counts, but the schema covers parameter constraints and the description gives enough context for correct tool selection and invocation.

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

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

Schema description coverage is 100%, so all seven parameters are already documented in the input schema. The description adds no parameter-specific meaning beyond what the schema provides, such as how filters combine or how cursor pagination works. Baseline 3 is appropriate.

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

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

The description states a specific verb ('List') and resource ('all workflows'), specifies that it returns full details, and lists the available filter dimensions. It actively distinguishes itself from the sibling tool n8n_list_workflows_summary by warning about the heavy payload, so an agent can tell them apart.

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 warning explicitly directs agents to n8n_list_workflows_summary when token efficiency matters, giving a clear alternative condition. However, it does not mention other relevant alternatives like n8n_get_workflow for fetching a single workflow, so the routing guidance is good but not exhaustive.

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 safe/read-only, and the description is consistent with that. It adds valuable behavioral context by explaining that snapshots are local to this server and are saved automatically before mutations, which clarifies what data can be expected and why.

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

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

Two concise sentences with no filler. The action is front-loaded, and the second sentence earns its place by explaining snapshot creation behavior. Every word adds value.

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

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

For a single-parameter, read-only tool, the description plus schema and annotations are largely sufficient. The main gap is the lack of an output schema or any mention of what fields the returned snapshots contain, but for simply listing snapshots of a workflow this is a minor omission.

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

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

The schema has 100% description coverage for the single `id` parameter ('Workflow ID'), so the description does not need to add much. It merely reinforces that the parameter identifies a workflow. This meets the baseline but does not exceed it.

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

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

The description states a clear action and resource: 'List local snapshots of a workflow.' This is specific and easily distinguishable from diff/rollback operations by the verb. It does not explicitly name sibling tools to differentiate itself, but the scope ('local') adds helpful clarity.

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

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

The description gives useful context about when snaps shots are created—automatically before every update, partial update, or delete—so an agent knows snaps shots should exist after such operations. However, it does not explicitly say when to choose this tool over related tools like n8n_rollback_workflow or n8n_diff_workflow_snapshot.

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 communicates that this is a safe read operation, and the description adds useful behavioral context: it returns a minimal field set and uses 90% fewer tokens than the full list tool. This goes beyond the annotation by explaining what data the agent will receive and why this variant is cheaper, though it does not discuss pagination 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 three short sentences with no filler: the first states the action and output fields, the second gives a concrete recommendation with quantified benefit, and the third routes to the full-detail alternative. Every sentence earns its place and the most important selection information is front-loaded.

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

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

For a simple list operation with read-only behavior and a fully documented schema, the description covers everything an agent needs: what is returned, why this variant is preferred, and how to get full workflow details. No critical usage or selection context is missing.

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

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

Schema description coverage is 100%, so each of the six optional parameters is already documented in the input schema. The description does not add parameter-level detail beyond the schema, which is acceptable given the high coverage; the baseline of 3 applies.

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

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

The description states a specific action ('List workflows') and resource, then precisely defines the scope as 'minimal data' with the exact returned fields (id, name, active, tags, updatedAt only). It also distinguishes itself from the sibling n8n_list_workflows by emphasizing the reduced data payload, so an agent can clearly differentiate the two.

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

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

The description explicitly recommends this tool for 'browsing and listing' and justifies it with the token-efficiency benefit versus n8n_list_workflows. It also names n8n_get_workflow as the appropriate alternative when full details of a specific workflow are needed, giving clear selection guidance.

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

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

readOnlyHint=true already signals a safe read operation, and the description is consistent by saying 'List'. It adds that results include metadata and concern pre-built workflows, but it does not disclose pagination, ordering, or the scope of 'available'. For a read-only list tool, 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?

Two short sentences with the main action front-loaded and the second sentence adding a usage purpose. There is slight redundancy between 'available workflow templates' and 'what pre-built workflows are available', but no significant waste.

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

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

For a simple, read-only list operation with well-documented optional parameters, the description is mostly sufficient. The main gaps are the lack of distinction from n8n_search_public_templates and the vague return description, especially since there is no output schema.

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

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

Schema description coverage is 100%, and both parameters (search and category) already have descriptive definitions in the schema. The description adds no parameter-level meaning, 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?

Clearly states the action ('List') and resource ('available workflow templates') and mentions that metadata is returned. However, it does not differentiate this from sibling tools like n8n_search_public_templates or n8n_get_workflow_template, and 'available' is ambiguous about whether these are built-in or public templates.

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 'Use this to discover what pre-built workflows are available' gives an explicit discovery use case. It does not mention alternatives or exclusions, so an agent receives no guidance on choosing between this and n8n_search_public_templates.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only says 'pull changes' without mentioning side effects such as overwriting local workflows, potential conflicts, authentication requirements, or whether the operation is reversible. This is a significant gap for a mutating operation.

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

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

The description is a single sentence with no filler, front-loaded with the action verb and target resource. It is maximally concise while still conveying 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?

While the tool is simple (0 params, no output schema), the description omits important contextual details like what artifacts are pulled (workflows, credentials?) and whether local changes are overwritten. An agent could invoke it without understanding the consequences, so the description is minimally viable but 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 has zero parameters, so there is no parameter documentation burden. The baseline for zero-param tools is 4, and the description is not expected to add parameter-level details where none exist.

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

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

The description states a specific action ('Pull changes') and resource ('remote source control repository'), making the tool's purpose clear. It is more specific than a tautology, though it doesn't explicitly distinguish from siblings because no other source-control tool appears in the list.

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

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

No explicit guidance on when to use this tool vs alternatives is provided. However, since no sibling tool references source control, the intended use case is somewhat implied, but the description offers no context about when a pull would be appropriate or when to avoid it.

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 include destructiveHint: true, which covers the safety profile. The description states the action but adds no extra behavioral context beyond that, such as whether removal is irreversible, whether it cascades to roles, or whether it is idempotent. It does not contradict the annotations, so it is acceptable but minimal.

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

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

The description is a single short sentence with no filler, front-loading the verb and both key resources. It is appropriately sized for a simple two-parameter operation, though it essentially restates the tool name without adding extra context.

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

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

The tool is simple: two required string parameters and no output schema, and the destructive nature is already captured in annotations. However, for a destructive membership operation, the description could note whether the action is reversible, what permissions are needed, or what happens to the user's project roles. The core invocation is specified well enough, but some operational context is missing.

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

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

Schema description coverage is 100%: both userId and projectId have descriptions in the input schema, so the structured schema already explains each parameter. The tool description adds no parameter-level meaning, but none is needed because the schema already handles that documentation.

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

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

The description uses a specific verb ('Remove') and names both resources (user, project), so the core operation is clear. It is distinguishable from sibling tools like n8n_add_user_to_project and n8n_change_user_project_role, though it does not explicitly clarify that this only removes project membership and does not delete the user account. Overall the primary purpose is clear and unambiguous enough for selection.

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

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

The description gives no guidance on when to use this tool versus alternatives such as n8n_change_user_project_role or n8n_delete_user. It also does not mention preconditions, exclusions, or consequences like whether the removal is permanent or whether certain users cannot be removed. The agent must infer usage solely from the tool name and the brief description.

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

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

No annotations are provided, so the description carries the full burden of disclosing behavior. It only states the action and does not explain side effects suchs whether a new execution is created, whether permissions are required, or what the function returns.

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

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

The description is a single front-loaded sentence with no filler, repetition, or unnecessary detail. For a one-parameter tool, this is appropriately sized and every word carries meaning.

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

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

For a one-parameter tool with full schema coverage this is nearly adequate, but the lack of annotations and an output schema means important context around results and side effects is missing. The description is enough to invoke the tool, but not enough to fully anticipate its behavior.

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

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

The input schema already provides 100% description coverage for the single parameter 'id' as 'Execution ID to retry'. The tool description adds no additional parameter meaning 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 ('Retry') and a specific resource ('a failed execution'), and the action is unique among the sibling tools. An agent can immediately distinguish this from list, get, and delete execution tools without needing extra context.

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

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

The phrase 'a failed execution' provides clear context for when the tool should be used: only executions that have failed and need another attempt. It does not mention exclusions or alternatives, but the use case is clear enough for a simple retry action.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It reveals a key trait: the current state is snapshotted first, so rollbacks are themselves undoable. It also explains the recreate behavior for deleted workflows, adding meaningful context beyond the obvious mutation implied by 'restore'.

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

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

The description is three sentences with no filler. The core action is front-loaded in the first phrase, followed by the most important behavioral guarantee (undoability) and the key edge case (deleted workflows). Every sentence earns its place.

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

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

For a tool with three well-documented parameters and no output schema, the description covers the main operation, the undo safeguard, and the deleted-workflow scenario. It does not mention effects on active/enabled workflows or permission requirements, but those are not essential for an agent to invoke the tool correctly.

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

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

The input schema already documents all three parameters with descriptions, reaching 100% coverage. The description only restates the 'latest by default' timestamp behavior and the recreate use case already present in the schema, so it adds no new semantic value beyond the baseline set by 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 opens with a precise verb and resource: 'Restore a workflow to a previous snapshot', clearly distinguishing this from sibling tools like n8n_list_workflow_snapshots or n8n_diff_workflow_snapshot. It also signals the recreate edge case, which further clarifies its unique role among workflow tools.

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

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

The description clearly establishes when to use the tool: to restore a workflow to a previous snapshot, with a specific condition for deleted workflows (recreate=true). It does not explicitly exclude alternatives like n8n_update_workflow or n8n_create_workflow, but the intended context is clear without needing to name them.

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

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

Annotations already mark this as readOnlyHint=true, so the safety profile is covered. The description adds useful behavioral context: the tool returns summaries, searches the full catalog, and serves as a precursor to n8n_get_node. It does not detail result structure or pagination, but for a read-only search tool the added context is meaningfully beyond the annotations.

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

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

Three sentences, no filler, and the most important facts come first: what the tool searches, when to use it, and how it relates to n8n_get_node. Every sentence 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?

This is a simple two-parameter read-only search tool. The description covers its purpose, catalog size, usage context, return type (summaries), and the related tool for full schemas. Nothing material is missing for an agent to select and invoke it correctly.

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

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

Schema description coverage is 100%, so both 'query' and 'limit' are already documented with descriptions and examples. The description adds context about the catalog and result type but no new parameter-level detail, so the baseline 3 is appropriate.

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

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

States a specific verb ('Search'), a precise resource ('the full catalog of 560 n8n nodes'), and its source ('extracted from the real n8n packages'). It also differentiates itself from the sibling n8n_get_node by noting it returns summaries rather than full parameter schemas, so an agent can distinguish the two tools immediately.

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?

Explicitly tells the agent when to use it: 'Use this BEFORE creating a workflow so node types are correct.' It also names the alternative for deeper detail ('use n8n_get_node for the full parameter schema'), giving both timing and a clear decision boundary.

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

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

Annotations already declare readOnlyHint=true; the description adds meaningful behavior beyond that: the source is official and current, and the result is summaries-only, which prevents an agent from expecting full template payloads. It does not mention pagination or rate limits, but these are not necessary for such a light read operation.

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

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

Three short sentences carry source, freshness, result type, and the next step. There is no filler, and the most important scoping information is front-loaded.

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

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

For a two-parameter read-only search tool with no output schema, the description supplies the essential context: what is searched, that results are summaries, and how to follow up. It would be more complete if it also told the agent when to use list_workflow_templates/get_workflow_template instead, but the description is adequate for correct selection and invocation.

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

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

The query parameter is already described in the schema as 'What the workflow should do', and the description's 'Search... templates' reinforces that. The limit parameter is left without prose, but its name plus the numeric constraints in the schema make it safe to infer. The description adds no real param detail beyond the schema, and with 50% schema coverage it does not fully compensate.

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

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

The description uses a specific verb ('Search'), names the exact resource ('official n8n.io workflow templates'), and clarifies scope ('thousands, always current', 'Returns summaries only'). It is clearly distinguishable from the import tool by naming it explicitly as a follow-up, so an agent can tell what this tool does without opening the schema.

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

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

It explicitly tells the agent what to do after searching: 'Then use n8n_import_public_template to copy one into the instance.' That is clear workflow context. It does not, however, state when to prefer n8n_list_workflow_templates or n8n_get_workflow_template for non-public or installed templates, so exclusions are missing.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. While 'transfer' implies moving the credential from one project to another, the description does not mention side effects such as removal from the source project, permission requirements, impact on workflows using the credential, or whether the operation is reversible.

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

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

The description is a single, front-loaded sentence with zero wasted words. It immediately communicates the action and target, making it easy for an agent to parse quickly.

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

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

For a simple two-parameter operation with fully documented schema fields, the description is minimally viable. However, the absence of any behavioral context, return-value expectations, or failure conditions leaves meaningful gaps for an agent deciding whether and how to invoke it safely.

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

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

Schema coverage is 100%, with both parameters already described as 'Credential ID' and 'Destination project ID'. The description adds no additional meaning or constraints beyond what the input schema provides, so the baseline score of 3 is appropriate.

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

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

The description states a specific verb ('Transfer'), a clear resource ('a credential'), and the target context ('to another project'). This precisely distinguishes it from sibling tools such as n8n_create_credential, n8n_delete_credential, and especially n8n_transfer_workflow, which shares the transfer verb but targets a different resource.

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

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

No guidance is provided about when to use this tool instead of alternatives, such as creating a copy of the credential in the destination project or transferring a workflow. There are no prerequisites, exclusions, or context cues to help an agent decide between this and related project/credential operations.

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

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

With no annotations, the description must carry the behavioral disclosure burden. 'Transfer' suggests a move, but the description does not state whether the workflow is removed from the source project, what permissions are needed, or what happens on failure or conflict.

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

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

The description is a single front-loaded sentence with no filler. Every word contributes to identifying the action and target, and there is no redundant restatement of the tool name.

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

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

For a simple two-parameter mutation, the description is minimally adequate and the schema covers the parameters. However, the lack of annotations and output schema increases the need for context about side effects and conditions, which is not provided.

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 fully documents both parameters with descriptions like 'Workflow ID' and 'Destination project ID'. The tool description adds no parameter-level detail beyond what the schema provides, so the baseline 3 applies.

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

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

The description states a specific action ('transfer'), the resource ('a workflow'), and the target ('another project'). This clearly distinguishes it from sibling tools like n8n_transfer_credential and from workflow CRUD operations.

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

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

No guidance is given about when to use this tool instead of alternatives, such as updating a workflow or transferring a credential. There are no exclusions, prerequisites, or routing cues beyond what the name itself implies.

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

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

With no annotations, the description carries the full behavioral burden. It discloses that the tool makes a real end-to-end invocation and returns the actual response, and it warns about the test-mode vs. active-mode requirement. It could go further in noting potential side effects of executing the workflow, but the essentials of what the tool does are clear.

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

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

Two well-crafted sentences: the first states the tool's purpose, and the second provides the crucial conditional guidance for the test parameter. No filler or redundancy, and the most important operational caveat is front-loaded in the second sentence.

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

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

Given 4 parameters, no output schema, and no annotations, the description does a good job covering purpose, execution mode, and the active requirement. It doesn't explain error cases (e.g., nonexistent path or inactive workflow), but those are secondary to correct invocation. The 'see the real response' phrase adequately covers the return value expectation.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds value beyond the schema by explaining when test=true is appropriate, which is a meaningful behavioral condition. It also reinforces the default method concept, though the schema already documents that.

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

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

The description states a specific verb ('Call'), a precise resource ('a Webhook-trigger workflow on the n8n instance'), and a clear goal ('test it end-to-end and see the real response'). It effectively distinguishes this tool from the many workflow-management siblings by focusing on triggering and testing rather than CRUD operations.

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

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

The description offers explicit conditional guidance: use test=true only during 'Listen for test event' mode, otherwise the workflow must be active. This tells the agent when a particular parameter setting is appropriate. While it doesn't explicitly name alternatives, no sibling tool provides a direct triggering alternative, so the context suffices.

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

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

With no annotations, the description carries the full burden for behavioral disclosure, but it only says 'Update a project.' It does not state whether the update is partial, whether omitted fields are reset, or what the response contains.

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

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

The description is one short sentence with no filler, but it is under-specified rather than appropriately concise. It repeats the tool name's meaning without providing any additional useful structure.

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

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

For a mutation tool with no annotations and no output schema, the description is not complete enough. The schema supplies the parameters, but the agent still lacks context about update semantics, return value, and when to prefer this tool over sibling project tools.

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 id and name, and the type enum is reasonably self-explanatory, but the description adds no parameter-level meaning. It does not clarify whether type changes are allowed or how omitted parameters affect the project.

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 'Update a project.' is a direct restatement of the tool name and adds no detail about what is actually updatable. It provides a verb and resource, but does not distinguish updating project attributes from related project membership or role update tools.

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

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

There is no guidance about when to use this tool versus creating, deleting, or managing project membership. It also does not mention prerequisites such as the project needing to exist before an update.

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

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

No annotations are provided, so the description carries the full behavioral disclosure burden. It communicates that the operation mutates a tag name but does not mention uniqueness constraints, permission requirements, idempotency, or what happens when the tag does not exist.

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

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

The description is extremely concise and front-loaded with the verb and resource. It contains no filler, though it is slightly terse and does not incorporate any usage or behavioral context that would make it more useful.

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

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

For a simple two-parameter update operation, the schema carries the parameter information and the description states the core purpose. However, with no annotations, no output schema, and no usage guidance, there are clear gaps around expected behavior and when this tool should be chosen.

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

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

Schema description coverage is 100% with clear 'Tag ID' and 'New tag name' descriptions. The tool description adds no additional parameter meaning beyond restating the operation, 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 ('Update'), a specific resource ('tag'), and the exact attribute being changed ('name'). It is unambiguous and distinguishes this tool from sibling operations like create_tag, delete_tag, get_tag, and update_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 provides no guidance about when to use this tool versus alternatives, no prerequisites, and no exclusions. It only states the action, leaving the agent to infer appropriate usage context from the tool name and schema.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the mutation intent ('Update') but does not explain partial versus full update semantics, validation of type/value, behavior when the ID is not found, or any side effects.

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

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

The description is short and free of fluff, but it is under-specified for a mutating tool with four parameters. Conciseness is fine, yet the sentence provides little detail beyond the tool name.

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 annotations, no output schema, and a four-parameter mutation tool, the description is incomplete. It does not explain update behavior, error conditions, return values, or how the parameters interact, leaving an agent without enough context to call the tool confidently.

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

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

The input schema already documents most parameters: id, key, and value have descriptions, and type is defined by an enum. The description adds no additional parameter meaning, but with 75% schema coverage the schema does the heavy lifting, so a baseline score 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 ('Update') and resource ('environment variable'), clearly identifying the operation and distinguishing it from sibling tools like n8n_create_variable, n8n_list_variables, and n8n_delete_variable. The resource name matches the tool name and the overall n8n variable context.

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

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

No guidance is provided about when to use this tool instead of alternatives such as n8n_create_variable, n8n_list_variables, or n8n_delete_variable. There is also no mention of prerequisites like the variable needing to already exist or whether this should be used for partial updates.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It explicitly reveals a nontrivial behavior: the tool fetches the current workflow and merges it automatically, which means omitted fields are preserved. This meaningfully exceeds what the tool name alone conveys, though it does not mention possible side effects, permissions, or failure modes.

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 exactly two sentences with no filler. The main action is front-loaded, and the second sentence earns its place by explaining the critical partial-update behavior. Nothing extraneous is included.

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 adequate for a straightforward update operation, and the schema covers all parameters. However, the close sibling n8n_update_workflow_partial creates ambiguity that the description does not resolve, and with no output schema or annotations, the agent still lacks clarity on return values and operational caveats.

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 beyond the schema by explaining the semantics of omitting optional parameters: they keep their current values due to automatic fetch-and-merge. This is valuable parameter context that the schema's field descriptions do not provide.

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

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

The description states a clear verb and resource: 'Update an existing workflow.' It clearly identifies what the tool does, but it does not distinguish itself from the similarly named sibling n8n_update_workflow_partial, especially since the description itself claims 'Supports partial updates,' which could blur the line between the two tools.

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

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

The partial-update behavior ('omitted fields keep their current values') implies when this tool is useful, but there is no explicit guidance about when to use this tool versus alternatives like n8n_update_workflow_partial or n8n_create_workflow. No exclusions or alternative routing are provided.

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