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

The description adds value beyond the annotations (readOnlyHint, idempotentHint) by disclosing token estimates for each detail level (minimal ~200 tokens, standard ~1-2K, full ~3-8K) and stating that modes return different content (e.g., docs = markdown documentation). No contradiction with annotations is present, and the extra context helps an agent anticipate response size and content.

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

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

The description is concise with two sentences, front-loading the main purpose and then listing details. Every sentence contributes useful information. The minor error ('format' vs 'mode') detracts slightly but the structure is efficient overall.

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

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

Given the tool's complexity (9 parameters, multiple modes), the description covers the main modes and detail levels but omits explanations of version-related modes (versions, compare, breaking, migrations) and parameters like includeExamples, includeTypeInfo, maxPropertyResults, toVersion, fromVersion. The schema covers these, but the description could provide more high-level guidance for a complex 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 includes detailed parameter descriptions. The description adds token counts for detail levels and groups modes concisely, but also repeats information already in the schema. The confusing 'format' reference slightly reduces clarity. Overall, the description provides marginal extra value over the schema, meeting the baseline for high coverage.

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

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

The description clearly states the tool gets node info with progressive detail levels and multiple modes, making the purpose well-defined. However, it introduces an inconsistency by saying 'Use format='docs'' when the parameter is actually named 'mode', which could confuse an agent. Still, the overall purpose is distinct from siblings like search_nodes or tools_documentation.

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 fails to provide explicit guidance on when to use this tool versus sibling tools (e.g., tools_documentation, search_nodes). It does not mention when-not to use it or suggest alternatives. The information on modes and detail levels helps with intra-tool choices but not tool selection.

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

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

The description adds value beyond the annotations by explaining the mode parameter's effect on response size, which the annotations (readOnlyHint and idempotentHint) do not cover. It does not contradict the annotations; rather, it complements them. The behavior of controlling output detail is clearly described.

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

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

The description is extremely concise: two short sentences that front-load the purpose and then explain the mode parameter. No wasted words.

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

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

Given the tool's simplicity (2 parameters, no output schema, no nested objects), the description is sufficiently complete. It covers the core retrieval purpose and the key parameter. However, it could optionally mention that the output is a workflow template JSON, but since mode 'full' implies 'complete workflow', it is adequate.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds minimal extra meaning beyond the schema—it only summarizes the mode options briefly ('nodes_only (minimal), structure (nodes+connections), full (complete workflow)') but does not provide additional context about templateId beyond what the schema already states.

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 'Get' and the resource 'template by ID'. It succinctly distinguishes the tool from siblings like search_templates by specifying retrieval via ID, and it also describes the mode parameter that tailors the response size, which is a key differentiator from other retrieval 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 provides explicit context for when to use this tool (when you have a template ID) and how to adjust the response size using mode. However, it does not explicitly state when not to use it or provide alternatives, though the sibling tool names (e.g., search_templates) imply that this is for direct ID lookup, not searching.

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

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

Annotations already indicate read-only, idempotent, non-destructive. Description adds value by explaining it returns a markdown report with remediation steps and combines built-in API with deep scanning, but does not reveal further behavioral traits like rate limits or authorization needs.

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

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

Three well-structured sentences: purpose, what it combines, and output format with remediation. No redundant information; every sentence adds value.

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

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

Given no output schema, description explains return format (markdown report with remediation steps) and mentions how to use results with sibling tools. Covers all key aspects for an audit tool with comprehensive annotations.

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

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

Schema coverage is 100% with descriptions for each parameter. Description reinforces the distinction between built-in categories and custom checks, adding meaning beyond enum values by explaining they correspond to 'built-in audit API' and 'deep workflow scanning' respectively.

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 specifies it's a security audit tool for n8n instance. Distinguishes from siblings by combining built-in audit API categories with deep workflow scanning, and mentions output as actionable markdown report with remediation steps referencing 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?

States what the tool does and what it checks, implying use for security auditing. References sibling tools for remediation but lacks explicit when-to-use vs alternatives or exclusion criteria.

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

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

Annotations indicate idempotentHint=true and destructiveHint=false, consistent with a non-destructive fixer. The description adds that fixes can be previewed or applied, and lists specific issue types. No contradictions.

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

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

The description is concise, front-loading the action and purpose in a single short paragraph. Every sentence adds value without redundancy.

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

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

The description covers what the tool does and lists fix types, but does not describe the output format or return value. Given no output schema, this is a gap for agents needing to parse results.

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 baseline 3. The description lists fixTypes but does not add significant meaning beyond the enum values. Parameters are adequately described in the schema.

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

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

The description clearly states the tool automatically fixes common workflow validation errors, with explicit examples of fix types (expression format, typeVersion, etc.). It distinguishes from sibling tools like validate_workflow by mentioning both preview and apply modes.

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

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

The description implies usage for fixing validation errors but does not provide explicit when-to-use vs when-not-to-use guidance or compare with alternatives like manual updates via n8n_update_*. No exclusions mentioned.

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

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

The description meaningfully supplements the annotations: it states the workflow is created inactive, requires the three core fields up front so an agent won't attempt degenerate calls, and notes the ID is returned. It also preserves schema nuances like nodeGroups being dropped on older versions in the schema itself. No contradiction with annotations (readOnlyHint=false, destructiveHint=false).

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 terse and front-loaded: the verb, the object, and the essential requirements appear in the opening sentence, with the outcome (inactive, gets ID) in a single follow-up. Every sentence earns its place; no redundant prose.

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

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

For a create action with a rich input schema and clear annotations, the description plus schema fully cover what an agent needs: required fields, optional settings, folder placement, enterprise projectId, behavior (inactive), return value, and version-specific caveats like nodeGroups and parentFolderId. No output schema is present, but the description explicitly states the returned workflow includes an ID, which is sufficient for a create call.

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

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

Schema description coverage is 100%, so the baseline is 3. The description itself mostly recaps the required names, while the schema already explains nodes, settings, projectId, nodeGroups, parentFolderId, and connections. The only added context is 'Created inactive' and the return of the workflow ID. The schema does the heavy lifting, so no more than a 3 is warranted.

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

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

The description states a clear verb and resource ('Create workflow') and enumerates requirements, which distinguishes it from update/delete/list siblings. It lacks an explicit differentiator naming which sibling to use instead, but the action is unambiguous enough for an agent to route correctly.

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: when creating a new workflow, and the schema clarifies required fields. It doesn't explicitly contrast with n8n_update_full_workflow or n8n_update_partial_workflow, nor mention validation steps like validate_workflow. Context is present but exclusions/alternatives are left 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?

The description reinforces the destructive hint from annotations by stating 'cannot be undone', but adds no new behavioral details beyond what annotations already provide.

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?

Extremely concise with two sentences, no superfluous information, and the key point 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 deletion tool with one parameter and annotations covering destructiveness, the description is adequate; however, it does not specify return value or confirmation behavior.

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

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

Schema coverage is 100% and the description adds no extra meaning to the single parameter (id) beyond its schema documentation.

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

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

The description clearly states the action (permanently delete) and the resource (workflow), distinguishing it from sibling tools like creation or listing.

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

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

No guidance on when to use this tool versus alternatives, no conditions or prerequisites mentioned, and no indication of when deletion is appropriate.

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

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

Annotations indicate it's not read-only and not destructive. The description adds behavioral details: auto-fixes common issues, returns workflow ID, credentials, and fixes applied. This goes beyond annotations, providing actionable 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 two sentences, front-loaded with purpose and followed by key details. Every word earns its place, with no unnecessary fluff.

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

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

With 5 parameters, no output schema, and no nested objects, the description is fairly complete. It explains the deployment workflow and return values. Could include more about auto-fix triggers, but sufficient for typical 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 coverage is 100%, so parameters are well-documented in the schema. The description adds context about the deployment process but does not elaborate on parameter semantics beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description clearly states the tool deploys a workflow template from n8n.io to the instance, using a specific verb and resource. It distinguishes from siblings like n8n_create_workflow and n8n_autofix_workflow by its unique purpose.

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

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

The description implies usage context (deploying from the library) but does not explicitly state when to use this tool versus alternatives like n8n_create_workflow or search_templates. However, the context is clear enough for an agent.

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

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

Beyond the annotations (readOnlyHint=false, destructiveHint=true), the description discloses version gating, API key scope requirements, the need for workflow:execute permission, and a performance warning for list_cases ('paginate - cases can be large'). It also explains what cancel does ('stop a running run'). No contradiction with annotations.

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

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

The description is three sentences, front-loaded with a clear summary and then requirements and an action list. Every sentence carries substantive information (prerequisites, action semantics, pagination warning) with no filler or repetition.

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 no output schema, the description explains key return concepts: 'aggregated metrics' for get_run, 'per-case results' for list_cases, and 'list runs for a workflow' for list_runs. It also covers prerequisites, action semantics, and pagination guidance. This is complete for a multi-action tool with six 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?

Schema coverage is 100%, so baseline is 3. The description adds value by explaining run requires an evaluation trigger, get_run returns aggregated metrics, and list_cases can be large and needs pagination, which enriches the meaning of the action parameter and relates to limit/cursor. It does not cover all parameters, but it goes 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 opens with 'Run and read evaluation test runs for a workflow,' which is a specific verb+resource statement. It clearly distinguishes this tool from siblings like n8n_executions and n8n_test_workflow by focusing on 'evaluation' test runs, and then enumerates the five actions.

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 explicit context for when the tool can be used, including version requirements (n8n >= 2.30 for reading, >= 2.32 for run/cancel) and permission requirements (API key scope, workflow:execute). It does not name alternative tools for exclusion, but the 'evaluation' qualifier and action list make the intended use clear.

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

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

Annotations already indicate destructive behavior and non-read-only status. The description adds value by specifying that delete 'removes the execution record' and clarifying the get/list/delete semantics. It does not contradict annotations, though it could further explain consequences like irreversibility.

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

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

The description is concise: two sentences front-load the core purpose and then give the primary action routing. Every sentence earns its place without redundancy or filler.

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

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

Given the high schema coverage and the tool's moderate complexity, the description is largely complete. It could add a note about response shape or mention that the delete action is irreversible, but the schema supplies the major parameter details and the description covers action selection.

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?

All 16 parameters have thorough descriptions in the schema, including enum values and per-action meaning, so the baseline is 3. The tool description itself does not add parameter-level detail beyond the action mapping, which the schema already covers.

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

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

The description clearly identifies the resource (workflow executions) and enumerates the supported operations: get details, list, and delete. It also maps each action to its purpose, making the tool's scope unambiguous and distinct from sibling workflow management 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 explicit guidance on when to use each action, including the default action and the role of 'id'. It does not explicitly compare against sibling tools or state when not to use this tool, but the action-level routing 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?

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false. The description adds useful behavioral context beyond this by noting that it uses an instance credential, that it requires N8N_MCP_ACCESS_TOKEN, and that it calls live resource resolution rather than returning static definitions. No contradiction with annotations.

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

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

The description is two dense, purposeful sentences. It front-loads the core action and examples, then immediately gives prerequisite lookup instructions. There is no filler or redundant repetition of the schema.

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

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

Given the tool's complexity (10 parameters, no output schema), the description is quite complete: it names the credential requirement, the two resolution modes, and the source tools for required parameters. It could go slightly further by describing the response shape (label/value items) and pagination behavior, but the schema covers paginationToken and the purpose is unambiguous.

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 around 90%, so the schema carries most paramater meanings. The description adds value by explaining where to find methodName/methodType and credentialId, and by connecting currentNodeParameters to loadOptionsDependsOn with an example. This goes beyond the raw schema.

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

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

Description names a specific verb and resource: 'Resolve the real options behind a node's dynamic dropdown (loadOptions) or resource-locator search (listSearch)'. It distinguishes itself from get_node by explaining that this tool resolves live options rather than returning the node definition, and gives concrete examples including Slack channels and Google Sheets tabs.

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

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

It clearly conveys when to use the tool (when workflow configs need real IDs behind dynamic dropdowns/listSearch) and tells the agent where to obtain prerequisites: methodName/methodType from get_node output and credentialId from n8n_manage_credentials list. However, it doesn't explicitly state when-not-to-use or compare against alternative tools beyond these references.

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, openWorldHint, idempotentHint. The description adds valuable context: explains the n8n draft/publish model, what each mode returns, and that active mode requires a live version. No contradictions with annotations.

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

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

The description is a single paragraph with no wasted sentences. It is well-organized, starting with the core purpose, then explaining the draft/publish model, then listing modes compactly. Every sentence adds value.

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

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

Given the tool's complexity (multiple modes, draft/publish model), the description covers key aspects. It explains what each mode returns, though a brief example of the output structure would enhance completeness. No output schema exists, but the description adequately hints at return types.

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

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

Schema has 100% coverage, so baseline is 3. The description adds meaning beyond schema: explains the draft/publish model, clarifies that mode='active' returns published graph, and suggests using mode='structure' first to discover node names for mode='filtered'.

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

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

The description clearly states 'Get workflow by ID with different detail levels.' It specifies the verb (Get), resource (workflow), and the key differentiator (different detail levels). This distinguishes it from sibling tools like get_node or get_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 description provides explicit context for each mode (e.g., 'use mode='active' to see the published graph', 'use mode='filtered' to read one heavy node'). It also warns that mode='active' errors if no live version. It could be improved with a more explicit 'use this when... and not when...' but is still clear.

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

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

Annotations already indicate readOnlyHint, idempotentHint. The description adds behavioral context by specifying the tool checks health and API connectivity, and explains the two modes (status vs diagnostic). It does not contradict annotations and provides useful operational insight.

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

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

The description is two sentences, front-loaded with the main purpose, and every word adds value. No unnecessary 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?

The description explains the two modes and hints at output (health info, env vars, tool status). However, without an output schema, more explicit detail on return structure would improve completeness. Still, it covers the essential context for a simple health check 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 coverage is 100% and both parameters are described in the schema. The description adds a use-case hint ('Use mode='diagnostic' for detailed troubleshooting'), which slightly adds value, but does not significantly extend 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 explicitly states 'Check n8n instance health and API connectivity', which is a specific verb+resource combination. It clearly distinguishes from sibling tools that focus on workflows, nodes, templates, etc.

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 advises using mode='diagnostic' for detailed troubleshooting, providing clear context on when to use each mode. While it does not explicitly mention alternatives, no other sibling tool serves the health check purpose, so this is 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?

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds meaningful behavioral detail beyond these: it reads the Public API first and falls back to n8n's MCP server only when team projects are not licensed and N8N_MCP_ACCESS_TOKEN is set. This documents an important environment-dependent 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?

Two sentences with no filler. The main action and scope are front-loaded, and the second sentence provides the fallback behavior without unnecessary wording. 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 tool with three simple parameters, annotations covering safety, and no output schema, the description is complete. It covers what is listed, why projects matter, and the auth/fallback path an agent needs to anticipate. An agent can correctly select and invoke this tool with the information 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 only 33%, so the description must compensate. It does add useful semantics for 'kind' by explaining that projects include the personal project marker and are needed as projectId for agents/data tables. The 'query' parameter is already described in the schema, and 'limit' has clear bounds. This is partial but adequate compensation.

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 ('instance-level catalog entries'), then enumerates exactly what is returned: projects or tags. It also clarifies why projects are useful ('needed as projectId for agents and data tables'), distinguishing this from siblings like n8n_list_workflows or n8n_manage_datatable.

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: use this to obtain project IDs or tags at the instance level. It does not explicitly name an alternative tool or state when not to use it, but the 'instance-level' scope and projectId use case provide enough guidance for an agent to select it appropriately.

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

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

Annotations already provide readOnlyHint and idempotentHint. The description adds value by clarifying the minimal metadata return and pagination behavior (hasMore/nextCursor). No contradictions.

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

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

Two concise sentences, front-loaded with the main purpose. Every sentence adds value with no wasted words.

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

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

For a read-only list tool with no output schema, the description fully covers return fields, pagination, and metadata scope. No additional details are needed.

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

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

Schema coverage is 100% with descriptions for all 6 parameters. The description does not add new parameter details beyond what the schema provides, so baseline 3 is appropriate.

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

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

The description clearly states it lists workflows with minimal metadata, specifies returned fields (id/name/active/dates/tags), and mentions pagination. This distinguishes it from sibling tools like n8n_get_workflow.

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

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

The description implies usage for listing workflows with limited data and pagination, but does not explicitly state when to avoid or use alternatives. The mention of minimal metadata helps agents infer 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?

Annotations already mark this as destructive and open-world, but the description adds crucial context: required N8N_MCP_ACCESS_TOKEN, n8n >= 2.34, real credentials and tools for call, and the approvals[] human-decision requirement. No contradiction with annotations exists.

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

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

The description is dense but front-loaded with purpose and prerequisities, followed by action list, workflow, and safety caveats. The action enum is partially redundant with the schema, but each sentence contributes actionable guidance.

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 15 actions and no output schema, it covers auth, version requirements, invocation order, destructive and publish caveats, call behavior, and sibling differentiation. The instruction to start with reference makes the tool effectively self-documenting for remaining details.

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

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

Schema coverage is 100%, so the baseline is 3; the description adds value by explaining action semantics (e.g., 'call runs the agent with real credentials', 'always with the latest configHash'). However, per-action args are deferred to tools_documentation, so it doesn't fully document all parameters.

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

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

Description states a specific verb and resource: 'Manage n8n Agents' and clarifies what an Agent is. It explicitly distinguishes itself from the AI Agent workflow node with 'This is not the AI Agent workflow node; use get_node for that.' This makes sibling differentiation clear.

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

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

Provides an explicit recommended sequence: reference → discover_assets → create → mutate → validate. Also gives conditional guidance such as 'publish only when the user explicitly asks' and warns against approving approvals[] on the user's behalf, plus an explicit alternative for the AI Agent node.

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?

Description includes delete action, which is destructive, but annotations set destructiveHint: false. This contradiction undermines transparency. However, the description itself is otherwise detailed about behaviors like NOT_SUPPORTED errors and security logging.

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?

Single paragraph with key info front-loaded. Somewhat dense but efficient for the complexity. Could benefit from bullet points but still readable.

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

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

Covers usage guidelines, edge cases (NOT_SUPPORTED), pagination, security, and parameter interactions. Lacks output format details but no output schema exists. Adequately complete for a multi-action 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 coverage is 100%, yet description adds significant value: explains cursor origin, includeUsage behavior (full scan, ignores limits), getSchema for data fields. This goes well beyond the schema 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?

The description clearly states the tool manages n8n credentials and lists all actions (list, get, create, update, delete, getSchema). It differentiates from sibling tools which handle templates, health, workflows, etc., making the purpose distinct and specific.

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

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

Provides explicit guidance: use getSchema before create, pagination with cursor for list, and notes on deployment compatibility affecting list/get. Does not explicitly state when not to use the tool, but contextual hints are 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 annotations already flag destructiveHint=true and readOnlyHint=false, and the description adds meaningful behavioral context: the public API cannot change table columns after creation, so those operations are routed through n8n's own MCP server with a token and version requirement. This gives the agent useful constraints beyond the structured 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 compact and front-loaded: it states the scope, lists all actions, then explains the key API split. The action list is long but necessary for a multi-action tool, 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 13-action, 17-parameter tool, the description is adequate at an overview level and the schema fills in parameter details. However, with no output schema, it does not explain return formats, error behavior, or broader usage boundaries, so the agent still has to infer several operational details.

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

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

Schema description coverage is 100%, with every parameter already documented in the input schema. The description itself adds no parameter-level meaning beyond the schema, 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 the resource ('n8n data tables, rows and columns') and enumerates 13 concrete actions, so an agent can see this is a broad CRUD hub for data tables. 'Manage' is generic, but the action list and resource make the purpose clear and distinguish it from sibling tools like n8n_manage_folders or n8n_manage_credentials.

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

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

The description gives an important internal routing rule: column actions require N8N_MCP_ACCESS_TOKEN and n8n 2.34+, while all other actions use the public API. However, it does not explicitly state when to prefer this tool over alternatives or when not to use it, leaving usage mostly implicit in the tool's 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?

Annotations already indicate destructive behavior (destructiveHint=true) and non-read-only. The description adds n8n version requirements, the projectId default to 'personal', and the critical limitation that folder contents are only visible as counts. No contradiction with annotations.

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

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

The description is four information-dense sentences, front-loaded with purpose and version requirements. Every sentence adds value and there is no filler or repetition.

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 complex 10-parameter tool with no output schema, the description plus schema covers actions, requirements, defaults, cross-tool relationships, and a key API limitation. Minor omissions like error handling or permission requirements are not critical given the schema's richness.

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

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

Schema description coverage is 100%, so baseline 3. The description repeats the projectId default and mentions parentFolderId in other tools, but adds no new parameter semantics beyond what the schema already provides.

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

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

The description clearly states the tool manages workflow folders and enumerates six specific actions (create, list, get, rename, move, delete). The note that the API cannot report which folder a workflow is in further distinguishes this tool's scope from sibling workflow-management 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?

It explicitly directs workflow-folder placement to n8n_create_workflow and n8n_update_partial_workflow, clarifying the boundary between folder management and workflow-to-folder association. It also gives version/instance requirements and warns about the API limitation, providing strong context. It could be more explicit about 'when not to use' but the guidance is solid.

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 only flag non-read-only, open-world, and potentially destructive behavior; the description adds the auth prerequisite (N8N_MCP_ACCESS_TOKEN), the side effect of toggling the persistent 'Available in MCP' setting with explicit user confirmation, the read-only nature of prepare, and the failure mode where auto reports that it cannot be triggered. No contradiction with annotations — the per-method read-only qualifier is consistent with a whole-tool destructiveHint=true.

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 carry the whole method model, the default behavior, and the auth prerequisite, front-loading 'Run a workflow' and method=auto. The middle sentence is dense with three methods packed into one clause, but for a 16-param, 5-method tool every clause earns its place and nothing is wasted.

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 this complex, the description plus a 100%-covered schema resolve almost every invocation decision: method selection, auth, prerequisites, and side-effect confirmation are all present. The notable gap is return-value semantics — with no output schema, the agent never learns what a run returns (execution ID? result data? error shape?), which matters when a workflow run starts a chained task.

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 every parameter already carries a precise semantic description, including pinData's wrapping rule, the timeout vs timeoutMs scoping, and executionMode's 'never chosen implicitly' caveat. The description adds the connecting glue — the method model and auth context — but the schema does the heavy lifting, so baseline 3 applies.

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

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

'Run a workflow' pairs a specific verb with a clear resource and is immediately differentiated from the 28 siblings (create/get/update/delete/list workflows). The method breakdown makes explicit that this tool executes, never manages, workflow definitions, and the trigger/HTTP vs MCP-server distinction removes ambiguity about what 'run' means here.

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 explicit routing logic: workflows with webhook/form/chat triggers use auto/trigger over HTTP, while triggerless workflows require prepare/pinned/direct through n8n's MCP server. It also states the fallback behavior (use exposeToMcp when n8n refuses) and the prepare-first requirement before pinned. It doesn't name exclusion conditions against sibling tools, but within the tool the when-to-use decision is unambiguous.

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 implies a full replacement behavior by requiring complete nodes and connections, which adds some context beyond annotations. However, it does not elaborate on side effects, return values, or error scenarios. Annotations cover read-only and destructive hints, so the bar is lowered, but the description still contributes limited behavioral detail.

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

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

The description is a single, well-structured sentence that front-loads the purpose, states the key requirement, and names the alternative. Every word adds value with no redundancy or filler.

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

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

Given the tool's 7 parameters and nested objects, the description is brief, but the schema provides rich parameter details and the description successfully conveys the critical distinction from the partial update tool. It lacks explicit mention of return behavior and the effect of omitting optional fields, but overall it is sufficiently complete for an agent given the schema richness.

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

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

The schema has 100% parameter coverage with descriptive text for each field, including 'Complete array of workflow nodes' and 'Complete connections object'. The description merely repeats the completeness requirement without adding new meaning, so it stays at the baseline 3.

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

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

The description clearly identifies the action as a 'Full workflow update' and specifies the resource. It explicitly distinguishes itself from the sibling tool by naming n8n_update_partial_workflow, making its purpose unambiguous and distinct.

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 provides explicit guidance by stating 'Requires complete nodes[] and connections{}' and directing users to the partial update tool for incremental changes. This gives clear when-to-use and when-not-to-use context.

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

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

The description goes beyond annotations by enumerating all operation types and detailing specific requirements for patchNodeField, setNodeGroups, and moveToFolder (including version note). This enriches the behavioral profile significantly, though it omits return format and potential side effects of removal operations. The annotation destructiveHint=false is not directly contradicted because the description does not explicitly claim non-destructive 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 dense but well-structured: one clear opening sentence, a list of operation types, and three specific clarifications. Every sentence adds value, and the final pointer to tools_documentation avoids redundancy. It is slightly long but appropriate for the tool's 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?

For a tool this complex, the description covers the main operation categories and critical constraints, including version requirements. However, it lacks specification of return values and error/atomicity behavior (though continueOnError is in the schema). The explicit reference to tools_documentation for full details partially compensates, but the absence of output description is a 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 coverage is 100%, giving baseline 3, but the description markedly enhances parameter understanding: it clarifies that operations must have a 'type' field and provides concrete shapes for key operations (e.g., patchNodeField with fieldPath and patches, setNodeGroups with name/nodeNames). This is far more informative than the generic array description in the schema.

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

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

The description starts with 'Update workflow incrementally with diff operations,' clearly stating the specific verb (update), resource (workflow), and mode (incremental diff). This distinguishes it from sibling tools like n8n_update_full_workflow and n8n_create_workflow, making its purpose immediately obvious.

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 'incrementally' implies usage for partial changes, contrasting with full replacement, but the description does not explicitly state when to use this tool over n8n_update_full_workflow or provide exclusions. It conveys clear context without naming alternatives or when-not cases.

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

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

Annotations already provide read-only, open-world, and idempotent hints. Description adds that it returns errors/warnings/suggestions but does not elaborate on response structure or edge cases.

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 conveying core purpose and output. No redundant information, well 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?

No output schema, so description should detail return format. Lacks explanation of validation profiles, which are documented only via enum values. Does not address potential confusion with sibling 'validate_workflow'.

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 detailed property descriptions. Description restates the parameters' purpose without adding new meaning or examples.

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

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

Description clearly states it validates a workflow by ID, checking nodes, connections, expressions, and returning results. However, it does not differentiate from the sibling 'validate_workflow', which may cause confusion.

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

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

No guidance on when to use this tool versus alternatives like n8n_audit_instance or n8n_health_check. Does not specify prerequisites or when not to use.

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

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

Annotations already flag destructive behavior, and the description goes further by disclosing side effects: rollback creates a backup first, delete and prune are local-only, prune retains 10 most recent versions automatically, and exposeToMcp is a visible persistent workflow setting requiring user confirmation. This exceeds what annotations alone provide and helps agents anticipate consequences.

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 well-structured with a clear first sentence, a compact mode list, and a source comparison section. It is longer than average, but the tool has 12 parameters and multiple modes, and every sentence contributes operational detail without repetition or filler.

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

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

The description covers modes, sources, prerequisites, side effects, and source-specific constraints, which is strong for a complex tool. It does not describe return value shapes or error conditions, and with no output schema present, some of that burden falls on the description; however, the core invocation context is nearly 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 input schema already documents all 12 parameters, including mode-specific behavior and defaults. The description adds high-level source semantics but does not meaningfully enrich individual parameter meanings beyond what the 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 opens with a specific verb and resource: 'Manage workflow version history, rollback, comparison, and cleanup.' It then enumerates six precise modes, making the tool's scope unmistakable. This clearly distinguishes it from sibling workflow tools like n8n_create_workflow or n8n_update_partial_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 provides clear context for when to use the tool via its six modes and explains the critical distinction between the 'local' and 'native' sources. It does not explicitly name sibling alternatives or state when not to use this tool, but the mode breakdown leaves little ambiguity about intended usage.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is clear. The description adds behavioral context: max 20 results, default limit, behavior of includeExamples and includeOperations (token cost per result). This exceeds the burden given the annotations.

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

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

The description is extremely concise: three sentences that front-load the purpose and immediately provide actionable examples and constraints. Every sentence earns its place without redundancy.

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

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

Despite having no output schema and 6 parameters, the description is complete: it covers query usage, results limit, and the two boolean options. The context signals show high schema coverage and no nested objects, so the description needs to do little else. The sibling differentiation is implicit but sufficient.

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

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

Schema coverage is 100%, so parameters are already well-documented. The description adds value by explaining the query parameter further (use quotes for exact phrase) and clarifying includeExamples and includeOperations behaviors beyond their schema descriptions. A small lift above baseline.

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

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

The description clearly states the tool searches n8n nodes by keyword with optional real-world examples. It distinguishes itself from siblings like search_templates or get_node by focusing on node search with template config examples, and from get_node by offering operations inclusion to save round-trips.

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 implicitly guides usage via example queries and mentions the trade-off of includeOperations (saves a round-trip to get_node). However, it does not explicitly state when to use this tool over siblings like search_templates or get_node, nor 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?

Annotations already declare readOnlyHint=true and idempotentHint=true, so the tool is safe and idempotent. The description adds behavioral clarity by detailing the five distinct search modes and their parameters (e.g., 'patterns' mode uses 2700+ templates for summaries), without contradicting annotations. The explanation of 'patterns' as lightweight summaries is extra context beyond annotations, but it lacks details on pagination behavior or result format, keeping it from a 5.

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 efficiently enumerates all five modes and their purposes without redundancy. Every clause adds value (e.g., 'lightweight workflow pattern summaries mined from 2700+ templates'), and it's front-loaded with the main action ('Search templates with multiple modes').

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 13 parameters, no output schema, and rich sibling context, the description is remarkably complete. It covers the core behavior (five search modes), when to use each, and hints at return differences (e.g., 'patterns' yields summaries). With readOnlyHint and idempotentHint annotations, no additional safety info is needed. The only minor gap is no explicit mention of result pagination, but the schema's offset/limit parameters suffice.

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 parameters. The description adds value by grouping parameters by search mode (e.g., 'query' for keyword, 'nodeTypes' for by_nodes), providing context not in the schema. However, for parameters like 'category' and 'targetAudience', the description only restates what the schema says, offering no deeper semantics, so it doesn't fully reach a 5.

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

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

The description clearly states the tool searches templates with multiple modes, enumerates each mode with its specific use case (e.g., 'searchMode=keyword' for text search, 'by_nodes' to find templates using specific nodes), and distinguishes itself from siblings like search_nodes (which likely searches for nodes, not templates). The explicit listing of five search modes provides a precise 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 explicitly tells when to use each mode (e.g., 'Use searchMode=keyword for text search, by_nodes to find templates using specific nodes'), which directly guides the AI agent in selecting the right approach. It implies that for template-related searches this tool is appropriate, while siblings like search_nodes are for node-level searches, providing clear separation of concerns.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the agent knows this is a safe, read-only operation. The description adds behavioral context beyond annotations: it explains that calling without parameters returns a 'quick start guide,' and that depth='full' provides 'comprehensive documentation.' This clarifies the different response modes. No contradictions with annotations.

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

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

The description is three sentences, each adding value: first sentence states the core purpose, second gives the default behavior, third explains the two optional parameters. It is front-loaded and contains no unnecessary words. 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?

Given the tool's simplicity (2 optional params, no output schema), the description covers the main use cases well. It explains all invocation modes. However, it does not describe the format of the returned documentation (e.g., markdown, text), which would be helpful for an agent. Still, it is largely complete for a straightforward documentation tool.

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

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

Schema description coverage is 100%, so the baseline is 3. The description mentions using the 'topic' parameter and 'depth="full"', but this mostly restates the schema's own descriptions. It adds minimal new meaning beyond what the schema already provides. Therefore, a score of 3 is appropriate.

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

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

The description clearly states the tool's purpose: 'Get documentation for n8n MCP tools.' It distinguishes itself from siblings (which deal with templates, nodes, validation) by explicitly focusing on tool documentation. The different invocation modes (no params, topic, depth) are also outlined, making the purpose very specific.

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

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

The description provides explicit usage guidance: 'Call without parameters for quick start guide. Use topic parameter to get documentation for specific tools. Use depth="full" for comprehensive documentation.' This tells the agent exactly when to use each parameter combination. It does not mention when not to use the tool or alternatives, but the sibling tools are sufficiently different that no further exclusion is needed.

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

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

Annotations already mark it as readOnlyHint true and idempotentHint true, so the description has less burden. It adds mode parameters and example usage but does not detail return format or success/failure behavior, which is partially covered by the output schema.

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

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

Two sentences with a clear example, no fluff. Could be slightly more compact by integrating the example into the main statement, but it is efficient and front-loaded with 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?

Given the complexity (4 params, nested objects, output schema) and 100% schema coverage, the description covers the key behavior. The output schema handles return details, so no further explanation needed. The example adds practical context.

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

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

Schema description coverage is 100%, so baseline is 3. The description provides an example for nodeType and config that goes beyond the schema by showing a practical use case. This adds value, earning a 4.

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

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

Clearly states it validates n8n node configuration with a specific verb and resource. Provides examples of nodeType and config to distinguish it from sibling tools like 'search_nodes' or 'get_node'.

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 describes two validation modes ('full' for comprehensive, 'minimal' for quick checks) and gives usage example. Context suggests siblings like 'validate_workflow' exist but no direct 'when not to use' is stated, though mode distinction sufficiently guides selection.

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

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

Annotations already provide readOnlyHint and idempotentHint, so the safety profile is clear. The description adds that it returns errors/warnings/fixes, which is useful but not extensive. Since annotations carry the behavioral burden, the description adds moderate value.

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

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

Two sentences, front-loaded with purpose and scope. Every word adds value. No redundancy or filler.

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

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

The description covers the tool's purpose and return type. An output schema exists, so return details are documented elsewhere. Slightly missing mention of the optional 'options' parameter, but the schema covers it. Overall adequate for a validation tool with rich structured data.

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 detailed descriptions for each parameter. The description mentions the validation categories (structure, connections, expressions) which map to options, but does not add new meaning beyond what the schema already provides. 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?

Clear verb+resource: 'Full workflow validation' specifies the action and scope. Lists what is validated (structure, connections, expressions, AI tools) and what is returned (errors/warnings/fixes). Distinguishes from sibling 'validate_node' by being for the entire 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?

States 'Essential before deploy' which implies when to use it, but does not explicitly mention when not to use it or alternatives like validate_node for single nodes. The context is clear but lacks exclusions.

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