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

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It explains the output variations ('minimal', 'standard', 'full') and the 'propertyQuery' search capability, but it does not mention error handling (e.g., unknown node type), whether data is fetched live from a registry, or any rate limits or permissions. The read-only nature is implied but not explicitly stated.

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 long, front-loaded with the primary purpose, and uses concise, informative language. Examples and parameter definitions are integrated without unnecessary verbosity.

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 and the lack of an output schema, the description adequately explains the return behavior (schema at different detail levels). It could further specify the exact response structure or error behavior for unknown node types, but for a schema retrieval tool, the current description is largely 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?

All three parameters (nodeType, detail, propertyQuery) receive meaningful semantic explanations in the description, going beyond the schema's bare types. It provides concrete examples for nodeType, defines the three detail values, and explains the purpose of propertyQuery. This fully compensates for the 0% schema description coverage.

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

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

The description clearly states the tool's function: 'Get the schema for one node type' with specific examples of how to specify the node (short name or full type). It distinguishes from sibling tools like search_nodes and list_packages by focusing on a single node's schema rather than searching 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?

The description provides clear context for using the 'detail' parameter and the 'propertyQuery' parameter, but it does not explicitly mention when to use this tool versus alternatives like search_nodes. The phrase 'Use propertyQuery to search within one node's properties instead' is a within-tool guidance, not a tool selection guideline. Thus, usage context is implied 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?

No annotations are provided, so the description carries the full burden. It discloses that the tool lists every category and includes counts, which conveys read-only, non-destructive behavior. It does not mention pagination, ordering, or authentication prerequisites, but for a zero-parameter, all-resource list operation, the description provides adequate transparency.

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

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

The description is a single, front-loaded sentence that immediately states the action and the key detail (counts). Every word earns its place, with no redundancy or filler. It is appropriately concise for a simple tool.

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

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

For a zero-parameter, no-output-schema tool with no annotations, the description is largely complete: it states exactly what will be returned (every category with counts). It could have mentioned potential edge cases like empty categories or sorted order, but the scope is simple enough that these are acceptable gaps. Overall, the tool is well-specified for its purpose.

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 no parameters (schema properties are empty), and schema description coverage is 100% vacuously. Per the rubric, a zero-parameter tool gets a baseline of 4. The description adds no parameter details, but none are needed, so the score reflects the 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's action: 'List every category in the node database, with counts.' It uses a specific verb (list), identifies the resource (categories), and adds context (node database, counts). This distinguishes it from sibling tools like search_nodes (search vs. list) and list_packages (packages vs. categories).

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: use this tool to retrieve all categories with their counts. However, it does not explicitly provide when-to-use vs. when-not-to-use guidance or mention alternatives such as search_nodes for targeted queries. The scope is clear, but the lack of explicit alternatives or exclusions leaves the guideline dimension at a basic level.

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 burden of disclosing behavior. It states the operation is to 'List' the packages, which inherently indicates a read-only action, and provides details about return value (node counts). While it does not explicitly mention side effects or permissions, the listing nature makes this adequate.

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

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

A single, well-structured sentence that front-loads the verb 'List' and includes concrete examples and output details. No wasted words or redundancy.

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

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

Given there are no parameters and no output schema, the description is sufficiently complete. It explains what the tool returns (source packages with node counts) and provides examples, covering everything an agent needs to invoke and interpret the result.

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 adds value by specifying the exact packages included and the node counts, giving context beyond the empty schema.

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

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

The verb 'List' clearly specifies the action, and the resource is precisely defined as 'source npm packages the node database was built from'. Including examples (n8n-nodes-base, @n8n/n8n-nodes-langchain) and the detail 'with node counts' makes the tool's purpose unambiguous and distinct from sibling tools like list_categories 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?

The description implies usage context by clearly stating what the tool does, but it does not explicitly mention when to use it over alternatives or provide exclusions. The agent can infer that this is for listing packages, but no direct comparison with siblings is 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, the description must carry the behavioral burden. It states the outcome (triggers start listening) but does not disclose potential side effects, idempotency, or whether the workflow must currently be inactive. The behavior is minimal but not misleading.

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 compact sentence that immediately states the action and effect, with no filler or redundant information. It is optimally concise.

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

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

For a simple one-parameter activation tool with no output schema, this description provides essential context for an agent to select and invoke it correctly. It lacks details on prerequisites or response format, but those are not critical for this 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?

The schema has one required 'id' parameter with 0% coverage, and the description does not explicitly explain that the id is for the workflow, though it is implied by the tool name. The description adds no parameter-level meaning beyond what the schema already shows.

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) and adds a clear effect ('so its triggers start listening'), distinguishing it from the sibling n8n_deactivate_workflow. The 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 implied usage is when you want to publish a workflow and enable its triggers, but the description does not explicitly state when to use this tool versus alternatives like n8n_update_workflow or n8n_validate_workflow. No exclusions or prerequisites 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 must disclose behavioral traits. It only says 'Create a new credential' and advises checking the schema, but does not mention side effects, permissions, return values, or error behavior. This leaves significant transparency gaps for a mutation 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 two concise sentences, with the action stated first and the prerequisite second. Every word adds value, and the structure is front-loaded and easy to parse.

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 relatively simple with 3 required params and no output schema. The description includes the critical prerequisite (checking the schema), but omits return behavior and any execution details. It is adequate for basic use but leaves gaps for a new user.

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 describes type and data with examples, and the description adds important context that data fields depend on the credential type and must be obtained from the schema tool. This compensates for the 67% schema coverage and clarifies the nested structure.

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

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

The description clearly states the action 'Create a new credential' with a specific resource, distinguishing it from sibling tools like get, delete, or list. The title adds context about a live n8n instance, reinforcing the 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 explicitly instructs to check n8n_get_credential_schema first for required data fields, providing clear when-to-use guidance by naming a prerequisite sibling tool. It does not mention exclusions, but the requirement is actionable and specific.

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 burden. It only states 'Create a new workflow' — a mutation — but does not disclose side effects, permission requirements, idempotency, conflict behavior, or output. The validate_workflow suggestion is useful but not about this tool's behavior. Minimal additional context beyond the tool name.

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

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

Two short sentences, with the core purpose front-loaded and the validation suggestion as a bonus. No fluff or redundancy; 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?

Given the complexity of a workflow object (nodes, connections, settings) and no output schema, the description is too sparse. It doesn't clarify return values, error handling, or the required structure of 'workflow'. The validate_workflow hint is helpful but doesn't compensate for the overall lack of context for this non-trivial creation tool.

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

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

Schema description coverage is 0%, yet the description does not explain the 'workflow' parameter or its structure. It only references 'workflow' as the target, but adds no meaning beyond the schema. The schema itself has some nested descriptions (e.g., node name), but the tool description fails to compensate for the coverage gap.

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

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

The description clearly states the action: 'Create a new workflow on your connected n8n instance.' It uses a specific verb ('Create') and resource ('workflow'), and the phrase 'new workflow' distinguishes it from update/delete/activate operations among 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?

It explicitly suggests 'Consider running validate_workflow first,' which is a clear alternative/related action. This gives the agent guidance on workflow validation before creation. It doesn't explicitly state when not to use this tool (e.g., for existing workflows), but the tool name and sibling context (update_workflow) imply this.

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 the action itself without explaining side effects (e.g., whether running executions are stopped, whether it is idempotent, 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 extremely short but under-specified. It is concise in length but fails to provide necessary context, so it trades effectiveness for brevity.

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 incomplete. It does not describe the result, error conditions, or what 'deactivating' entails, leaving significant gaps for the agent.

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

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

Schema description coverage is 0%, and the description adds no detail about the 'id' parameter. While the parameter name implies it is a workflow ID, the description fails to clarify that or any constraints.

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

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

The description 'Deactivate a workflow' clearly states a specific action (deactivate) on a specific resource (workflow). It distinguishes from sibling tools like n8n_activate_workflow and n8n_delete_workflow, though it adds no 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?

No guidance is provided on when to use this tool versus alternatives (e.g., when to deactivate vs. activate or delete). There is no mention of prerequisites, effects, 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?

With no annotations, the description carries the full burden of behavioral disclosure. It mentions permanence but omits consequences like whether deleting a credential affects workflows that reference it, error behavior, or authorization requirements. The single phrase is minimal and lacks depth.

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 words. It is appropriately concise for a simple delete operation, though it sacrifices content for brevity. Structure is clean 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?

The tool has one parameter, no output schema, and no annotations, so the description must provide complete context. It fails to describe return values, error conditions, or the meaning of 'id', leaving the agent without enough information to invoke it correctly in a real scenario.

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

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

Schema description coverage is 0% and the description does not explain the 'id' parameter. The agent is left without guidance on what id represents or how to obtain it, making the parameter semantics effectively undocumented beyond the schema's bare property name.

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 ('credential'), distinguishing it from sibling delete tools like n8n_delete_workflow. The term 'permanently' adds scope and irreversibility, making the 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?

There is no guidance on when to use this tool versus alternatives, such as n8n_get_credential for read-only operations or n8n_update_credential for modifications. No prerequisites, exclusions, or usage context 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 no annotations, the description carries the full burden of behavioral disclosure. 'Delete' implies destructive action, but the description does not mention irreversibility, permission requirements, potential side effects, or limitations (e.g., whether running executions can be deleted).

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

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

The description is a single concise sentence that does not waste words. It is appropriately front-loaded, though it may be too brief to cover necessary 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?

For a destructive tool with no annotations and no output schema, the description is too sparse. It does not explain what identifies the execution, whether deletion is permanent, or what happens after deletion. This is inadequate for an agent to safely invoke 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 0%, and the description provides no explanation of the 'id' parameter. It is only implicitly clear that 'id' refers to the execution record's identifier. The description fails to compensate for the schema's lack of detail.

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

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

The description clearly states a specific action ('delete') and a specific resource ('execution record'), distinguishing it from sibling tools like 'delete_workflow'. However, it lacks context about the 'live n8n instance' scope mentioned in the title.

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 versus alternatives. There is no mention of prerequisites, exclusions, or relationships to sibling tools like n8n_list_executions or n8n_get_execution.

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?

Since no annotations are provided, the description carries the full burden. It states that deletion is 'permanent', which is a key behavioral trait. However, it does not disclose other important behaviors such as whether the workflow must be deactivated first, whether associated executions are removed, or error conditions. The 'permanent' qualifier adds some value, but significant gaps remain.

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

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

The description is a single, front-loaded sentence that is easy to parse. It wastes no words, though it sacrifices informational content for brevity. It is appropriately concise for a simple operation, though it could be slightly more informative without losing efficiency.

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 no annotations, the description is the sole source of context. It covers the basic action but omits crucial details about side effects, error scenarios, or success/failure responses. Given the irreversible nature of deletion, more information is needed for safe and 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 has only one parameter 'id' with no description, and schema description coverage is 0%. The tool description does not mention the parameter or its meaning. While the context implies 'id' is the workflow ID, this is not explicitly stated, leaving the agent to infer the semantics.

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 'delete' and the resource 'workflow', and notes the action is permanent, distinguishing it from other delete operations on executions or credentials. It is specific and 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 provides no guidance on when to use this tool versus alternatives, no exclusions, and no mention of prerequisites (e.g., workflow must be inactive). Usage is only implied by the tool name and description, not explicitly stated.

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

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

With no annotations, the description carries the full burden. It adds the important behavioral note that 'secrets are never returned', which is a safety-relevant trait. However, it doesn't disclose other behavioral aspects like whether it is a read-only operation (implied), error behavior, or idempotency, leaving gaps.

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 (11 words) that is immediately informative. There is no wasted text, and the phrase 'secrets are never returned' adds crucial context without padding.

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 fetch tool, and the description covers the core purpose and a key constraint (secrets are not returned). However, it does not specify what metadata fields are included or address error scenarios. Given the simplicity and presence of a clear 'metadata' term, the description is mostly adequate.

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

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

The schema has zero description coverage for the single 'id' parameter. The description says 'by id', which clarifies that the parameter is the credential identifier, but it doesn't add further detail about format, required syntax, or what constitutes a valid ID. It provides minimal additional value beyond the parameter name.

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: 'Fetch one credential's metadata by id'. This specifies a distinct verb and resource, and the 'by id' scope differentiates it from listing all credentials or fetching a 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 description implies usage when a specific credential ID is known, but it does not explicitly mention when not to use this tool or suggest alternatives. Sibling tools like n8n_list_credentials exist, but this description doesn't provide direct comparison or exclusion 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 present, so the description carries the full burden. It discloses that the tool returns a JSON schema indicating required fields and that the result is used as the `data` payload for credential creation. However, it does not mention error behavior, authentication needs, or the exact structure of the returned schema, leaving some behavioral traits implicit.

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 first sentence states the core function, and the second provides usage guidance and an example. Information is front-loaded and 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 simple one-parameter tool, the description covers what it does, what it returns (a JSON schema), and when to use it. The lack of an output schema is mitigated by the explicit mention that it returns a 'JSON schema'. A minor gap is not showing an example of the returned schema structure, but the tool's simplicity makes this acceptable.

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 only provides the type (string) for `credentialTypeName`, with 0% coverage in the description. The description adds meaning by clarifying that it represents a credential type and provides an example ('slackOAuth2Api'), enabling the agent to understand and populate the parameter correctly.

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 specifies the exact action ('Get the JSON schema') and resource ('for a credential type'), with a concrete example ('slackOAuth2Api'). It clearly differentiates from sibling tools like n8n_get_credential (which fetches an existing credential) and n8n_create_credential (which creates one) by focusing on the schema lookup.

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 states when to use the tool: 'Use this before n8n_create_credential to know what `data` to send.' This names the relevant alternative and provides a clear contextual workflow, satisfying the 'explicit when/alternatives' criterion.

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. It only says 'fetch by id' and doesn't disclose whether it fails on missing IDs, what 'details' includes, or how the includeData parameter affects the response. Minimal behavioral context beyond the obvious 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?

The description is a single, concise sentence that front-loads the key action. It's efficient with no fluff, though it misses important parameter information. Still, length is appropriate for a simple get-by-id 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 tool with no annotations and no output schema, the description is too sparse. It doesn't explain what details are returned, what includeData does, or any error behavior. Given the low complexity, a bit more context would be needed to fully understand 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 coverage is 0%, so the description must compensate. It references 'by id' for the id parameter, but completely omits any explanation of includeData. The schema provides only type info, leaving the meaning of includeData unclear.

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 ('Fetch') and the resource ('one execution's details by id'). It distinguishes itself from sibling tools like n8n_list_executions (which lists many) and n8n_delete_execution (which deletes). The verb and resource are specific.

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

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

No guidance is given on when to use this tool vs alternatives. It doesn't mention that list_executions is for summaries, or that this is for retrieving full details of a single execution. No exclusions or prerequisites are stated.

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

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

No annotations are provided, so the description must disclose behavioral traits. 'Fetch' implies a read-only operation, but there is no explicit statement about safety, permissions, or side effects. It doesn't add any behavioral context beyond the verb itself.

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

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

The description is a single sentence, front-loaded with the verb and resource, with no wasted words. It's optimally concise and structured.

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

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

For a simple fetch-by-id tool, the description covers the core purpose and even mentions 'full definition' to hint at the return value. However, it omits the behavior of excludePinnedData and provides no details about response structure or error cases, which is a notable gap given 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 0%, so the description must compensate. It clarifies the 'id' parameter via 'by id', but completely ignores 'excludePinnedData'. Without explanation, the agent cannot know what that parameter does or when to set 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 clearly identifies the action ('Fetch'), the resource ('one workflow'), and the scope ('full definition by id'). It effectively distinguishes this from sibling tools like n8n_list_workflows (listing) and n8n_get_execution (executions).

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 usage context: when you need a single workflow's full definition by ID. It doesn't explicitly state alternatives or exclusions, but the clear verb and resource make the intended use obvious. A slight deduction for not mentioning what to use for listing workflows.

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 the tool checks environment variable presence, reachability, and authentication, but it does not describe the output format (e.g., success/failure status) or error behavior. This is basic transparency without deeper context.

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

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

The description is a single sentence with no redundant words. It is front-loaded with the main purpose and is appropriately sized for this simple tool.

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

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

Given the tool's simplicity (no parameters, no output schema), the description covers the core behavior. However, it could briefly mention what the tool returns or how results are communicated, but this is not critical for a 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?

There are zero parameters in the schema, so the baseline is 4. The description adds valuable context by explicitly naming the environment variables (N8N_API_URL/N8N_API_KEY) that the tool checks, which informs the agent about external dependencies beyond the empty schema.

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

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

The description uses a specific verb (Verify) and resource (N8N_API_URL/N8N_API_KEY, instance connectivity/authentication), clearly distinguishing it from sibling workflow/credential tools. It is not a tautology and precisely states what the tool does.

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

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

The description implies the tool is used to check connectivity/auth before other n8n operations, but it does not explicitly say 'use when...' or mention alternatives. Usage context is inferred from the purpose, but no explicit guidance is provided.

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

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

With no annotations, the description carries the full burden and it discloses a critical behavior: secrets are never returned and only metadata is provided. This adds valuable context beyond the schema, though it does not mention pagination behavior or authentication 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, front-loaded sentence that clearly states the action and a key caveat. There is no wasted text; every word earns its place.

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

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

The description covers the essential purpose and a critical behavioral note. It does not explicitly explain pagination parameters, which would improve completeness, but the tool is simple and the parameter names are self-explanatory, so the overall context is mostly 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 description coverage is 0%, and the description does not mention the 'limit' or 'cursor' parameters at all. Since the schema only provides types and constraints, the description fails to compensate for the lack of parameter documentation, leaving their semantics entirely to inference.

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

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

The description clearly states the tool's function with a specific verb 'List' and resource 'credentials', and adds the qualifier 'metadata only' to distinguish it from other credential operations like get, create, or delete. This differentiates it well from 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 implies the tool is used when you need a list of credentials rather than a single credential, but it does not explicitly name alternatives like n8n_get_credential. It provides clear context but no when-not-to-use guidance.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. 'List recent workflow executions' implies a read-only operation but gives no details about pagination (cursor/limit), default ordering, supported filters (status, projectId, workflowId), or return format, which are critical for an agent to invoke it safely and effectively.

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 core action, but it is under-specified. It has no additional structure or elaboration, making it minimally viable without being informative.

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 five parameters, no annotations, and no output schema, the description is incomplete. It does not address pagination, filtering options, or the expected response structure, which are necessary for an agent to confidently use this tool in a 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?

The schema has 5 parameters with 0% description coverage, and the description mentions none of them. It fails to explain how limit, cursor, status, projectId, or workflowId affect results, leaving the agent without any semantic context for these fields beyond their names.

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

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

The description uses the specific verb 'List' and identifies the resource as 'recent workflow executions,' which clearly conveys a collection-level read operation. This distinguishes it from sibling tools like n8n_get_execution (single execution) and n8n_delete_execution (mutation), though it omits the n8n instance context present in the title.

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. It does not mention that n8n_get_execution is for fetching a single execution, nor does it discuss use cases like monitoring or debugging, leaving usage entirely to inference.

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

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

With no annotations present, the description carries the full burden of behavioral disclosure. It says only 'List workflows,' which implies a read-only operation but does not disclose pagination behavior, rate limits, or what data is returned. This is minimal disclosure for a live API 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 clear sentence with no filler, making it concise and front-loaded. However, its brevity is a double-edged sword: it is not verbose, but it omits important details, which is captured in the completeness dimension.

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 (6 optional parameters, no output schema, no annotations), the description is severely inadequate. It provides no information about input semantics, return value structure, pagination, or edge cases, making it nearly impossible 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?

Schema coverage is only 17% (only 'tags' has a description), yet the description adds no parameter information. It fails to explain name, tags, limit, active, cursor, or projectId, leaving the agent without any semantic understanding of the six optional parameters.

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

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

The description clearly states the tool lists workflows from the connected n8n instance, using a specific verb ('List') and resource ('workflows'). It distinguishes from sibling tools like get, create, update, and delete workflows, though it doesn't explicitly contrast with list_executions.

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

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

The description provides no guidance on when to use this tool versus alternatives such as n8n_get_workflow or search_nodes. The only context given is 'connected n8n instance,' which specifies the environment but not the conditions or scenarios 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?

With no annotations, the description must disclose behavioral traits, but it only explains the URL mechanics. It does not mention that triggering a webhook executes the workflow, which may have side effects, require authentication, or be rate-limited. This is a significant gap for a trigger 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 two sentences, front-loaded with the key purpose, and contains no fluff. Every sentence adds value, explaining both the 'why' and the 'how' efficiently.

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

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

The description covers the core purpose and the webhook path format, but it does not clarify important prerequisites such as the workflow having a Webhook/Form trigger node or being active. It also omits any mention of the response format or error handling, which is more important given the lack of an 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?

The description adds valuable context for the required 'webhookPath' parameter by explaining how to extract it from a webhook URL. However, it does not elaborate on 'body' or 'method' parameters, leaving their semantics to the schema. This partially compensates for the 50% schema coverage.

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

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

The description clearly states that the tool triggers a workflow via its webhook URL, using a specific verb and resource. It also distinguishes this tool from siblings by explaining the public API's limitation and positioning webhook triggering as the real way to run a workflow over HTTP.

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 this tool, noting that the public API lacks a 'run workflow now' endpoint and that this tool fills that gap. It does not explicitly list exclusion criteria or alternative tools, but 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?

With no annotations, the description correctly conveys the destructive/replacement nature of the operation by stating it's a full replace. It also warns about the API limitation. However, it does not explicitly mention side effects like whether the workflow's active status or other metadata is preserved, but the 'fetch first' instruction covers the most critical behavioral nuance.

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 core action, and provides the necessary context in a clear, efficient manner. There is no wasted wording, and the key warnings are included 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?

For a mutation tool with a nested workflow object and no output schema, the description is reasonably complete. It explains the update workflow and the full-replace constraint. Missing details like error handling or activation state are secondary, and the instruction to fetch first covers the main context needed 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 schema has 0% coverage, so the description must add meaning. It implies that the 'workflow' parameter should be the full workflow object obtained from n8n_get_workflow, and 'id' is the workflow ID. This gives some semantic context, but it does not explain the structure or required fields beyond what the schema shows. It adds moderate value but not enough to fully compensate for the lack of 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's action ('Replace a workflow's definition entirely') and specifies the resource (a workflow on a live n8n instance). It also distinguishes itself from partial updates and from sibling operations like create and get by emphasizing 'full replace' and pointing to n8n_get_workflow as a prerequisite.

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 provides usage guidance: fetch the workflow first with n8n_get_workflow, edit it, then send the whole thing back. It explains why this is necessary (the public API only supports full-workflow PUT), making the usage context clear and preventing misuse of the tool.

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

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

No annotations are provided, so the description carries the burden. It discloses that the tool fetches and runs 'full local validation', implying a read-only operation without execution. However, it does not describe what happens on invalid/nonexistent ids, whether the operation is non-destructive, or what the return structure is. The phrase 'same checks as validate_workflow' adds context but relies on knowledge of another tool.

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

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

The description is a single sentence that is efficient and front-loaded. It communicates the core action, the source, and the validation method without unnecessary words. The parenthetical 'same checks as validate_workflow' is valuable context 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 simple tool with one parameter and no output schema, the description provides a reasonably complete picture: it fetches a workflow by id and validates it locally. It does not mention return values or prerequisites (e.g., connection setup), but these are implicitly covered by the tool name and sibling context. The description is sufficient for an agent to understand the tool's role and basic execution.

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 a single required string 'id' with no description (schema description coverage 0%). The description says 'by id', which gives minimal semantics—it's a workflow id on the connected instance. However, it does not specify where the id comes from (e.g., n8n_list_workflows) or any format requirements. The description only partially compensates for the lack of 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 uses a specific verb+resource combination: 'Fetch a workflow from your connected n8n instance by id and run full local validation against it.' This clearly distinguishes it from siblings like n8n_get_workflow (fetch only) and validate_workflow (presumably works on provided workflow definitions). The phrase 'same checks as validate_workflow' ties it to an existing sibling but does not explicitly spell out the differentiator beyond the 'by id' fetch.

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 use case: when you have a workflow id and want to validate the live workflow on the n8n instance. However, it does not explicitly state when to use this tool versus alternatives, nor does it mention when not to use it (e.g., if you have a workflow definition, use validate_workflow directly). The reference to validate_workflow is helpful but lacks explicit exclusions or alternative 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It adds significant value by revealing the use of SQLite FTS5, the scope of 538 node types, and the browsable fallback behavior when query is empty. It does not detail output format or default limit, but for a read-only search tool this is a reasonable level of 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 compact, two sentences, and front-loaded with the core search capability. Every clause adds useful information—search technology, catalog size, searched fields, and empty-query behavior—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?

For a tool with 4 optional parameters, no output schema, and no annotations, the description provides the essential context: what is searched, how to browse, and the package scope. It does not specify default limit or output shape, but these are minor gaps for a search tool and the description is sufficient for an agent to select and invoke the tool correctly.

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

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

Schema description coverage is 50%, and the description compensates by clarifying the query parameter ('leave query empty to browse'), the package scope ('core + AI/langchain' maps to the packageName enum), and the searched fields. The limit parameter remains under-explained, but the description meaningfully enriches the semantics of the main filters.

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 ('search') with a defined resource ('all 538 node types') and explicitly lists the searched fields (name, description, keywords). It also distinguishes itself from sibling tools like list_categories and get_node by emphasizing full-text search across the entire node catalog.

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 a clear usage instruction: 'Leave query empty to browse by category/package.' While it does not name alternatives explicitly, the context of sibling tools and the specific browse behavior makes the primary use case evident. It gives useful guidance on when to use the query vs. category/package filters.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the tool provides a usage guide and that management features are conditional ('if configured'), informing the user about potential limitations. However, it doesn't explicitly state that the tool has no side effects or that it returns text/markdown, which would be helpful.

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

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

The description is a single, front-loaded sentence that immediately states 'Usage guide' then expands with specific topics and a call-to-action. 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 documentation tool with no parameters and no output schema, the description covers the key aspects: what it is, what topics it covers, and when to call it. It could mention the output format, but overall it's sufficient for a simple guide tool.

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

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

The tool takes zero parameters, so the schema is empty. The description doesn't need to explain parameters; the 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 opens with 'Usage guide', clearly identifying the tool's function as providing guidance. It enumerates covered topics (looking up nodes, validating configs, managing n8n instance) and distinguishes it from sibling tools by positioning it as the starting point ('Call this first').

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 states 'Call this first if unsure where to start', providing clear when-to-use guidance. The 'recommended workflow' phrasing implies this is the entry point for other operations, though it doesn't explicitly name alternatives.

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 burden. It discloses that minimal mode respects displayOptions.show/hide, and full mode adds warnings for unknown parameters/type mismatches. It does not mention return format, side effects, or error behavior, which would be useful for a validation 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 sentences that front-load the purpose and then elaborate on modes. No wasted words; the technical detail about displayOptions is relevant but concise.

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

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

The description covers the tool's core behavior and modes. Since there is no output schema, it would be stronger if it mentioned the return format (e.g., list of errors/warnings), but it is adequate 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 coverage is only 33%; the description adds meaning to the 'mode' parameter by explaining the difference between minimal and full, and contextualizes 'config' as the node's parameters object. However, 'nodeType' is not explicitly explained, leaving some inference required.

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 ('Check') and resource ('a node's parameters against its schema'), clearly distinguishing it from sibling tools like validate_workflow. It also explains two modes, giving a concrete sense of what the tool evaluates.

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 it clear this is for validating a single node's configuration, not a whole workflow (contrast with validate_workflow). It explains when to use minimal vs full mode, but does not explicitly name alternatives or state 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?

With no annotations, the description takes on the burden of disclosure. It transparently lists the validation categories, which is good, but it does not disclose the output format (e.g., list of errors, boolean, exit code) or any behavior like whether it modifies the workflow. Since there is no output schema, this missing return-value information is a 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, well-structured sentence with a colon introducing the list of validation checks. Every word is informative with no filler, and the most important phrase 'Full validation' 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?

The listing of checks provides a good overview, but the tool is complex (validates many aspects) and lacks annotations and an output schema. The description does not explain what the result or error report looks like, nor does it explicitly relate to sibling validators. It is sufficient for a basic understanding but incomplete for a fully self-contained tool.

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

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

The schema has 0% description coverage, so the description must compensate for the sole 'workflow' parameter. It only calls it an 'n8n-format workflow' and does not explain the expected structure, required fields (nodes and connections), or how to construct it. The schema already provides the type structure, but the description adds minimal value for parameter usage.

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 performs full validation of an n8n workflow and enumerates the specific checks (unknown node types, required fields, connection structure, cycles, unreached nodes, missing trigger, expression brace balance). This distinguishes it from the more specific sibling validators like validate_node, validate_workflow_connections, and validate_workflow_expressions.

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 comprehensive validation through the word 'Full' and the list of checks, but it does not explicitly state when to use this tool over alternatives like validate_workflow_connections or validate_workflow_expressions. No exclusions or prerequisites 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?

With no annotations, the description carries the burden of behavioral disclosure. It lists what is checked but does not disclose output format, error behavior, or whether it is read-only. As a validation tool it is presumably safe, but that is not stated.

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

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

A single sentence with a colon-separated list delivers maximum information efficiently. The phrase 'Just the structural checks' front-loads the purpose, and every word 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?

The tool has one complex nested parameter, no output schema, and no annotations. The description fails to mention what the tool returns (e.g., list of errors, boolean) or how results are presented. This is a significant gap for an agent to understand the tool's behavior after invocation.

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

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

Schema description coverage is 0%, and the description provides no details about the 'workflow' parameter. It only implies the workflow object is the subject of checks. The schema itself provides some structure (nodes, connections required), but the description adds no semantic value for parameter usage.

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 lists specific structural checks (unique node names, valid connection references, cycles, unreached nodes, missing trigger node), making the tool's purpose explicit and distinct from siblings like validate_workflow or validate_workflow_expressions. The phrase 'Just the structural checks' further narrows its scope.

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

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

The description implies when to use this tool by limiting it to 'structural checks' only, which suggests using it when only connection structure validation is needed, not full workflow validation or expression checking. However, it does not explicitly mention alternatives or state 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?

No annotations are present, so the description carries the full burden. It discloses scanning and flagging behavior, but does not explain what 'flag' means in terms of output or side effects. It lacks details about return format, exceptions, 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?

The description is a single, action-oriented sentence with no wasted words. It is front-loaded with the main action and immediately states what it checks and what it flags.

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 complex nested input schema, lack of output schema, and absent annotations, the description is inadequate. It does not describe what the tool returns or how success/failure is communicated, leaving the agent with significant unknowns for a validation tool.

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

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

Schema description coverage is 0%. The description does not describe the 'workflow' parameter or how to provide it, instead relying entirely on the nested schema. It adds minimal meaning beyond the schema, merely referencing 'node parameters'.

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

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

The description uses a specific verb 'Scan' and identifies the exact resource 'node parameters' with '{{ }}' expressions, clearly distinguishing this tool from siblings like validate_workflow and validate_workflow_connections. It is precise about what it validates.

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 expression validation but provides no explicit guidance on when to choose this tool over other validators, nor does it mention any exclusions or alternatives. Context is clear but only implied.

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