n8n MCP Server

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v1.0.0
Disambiguation4/5
Most tools have distinct purposes targeting specific resources like workflows, credentials, projects, tags, users, variables, and executions. However, some tools like 'create-users' and 'delete-user' (singular vs plural) could cause minor confusion, and 'get-workflow-tags' vs 'update-workflow-tags' are closely related but still distinguishable.
Naming Consistency5/5
Tool names follow a highly consistent verb-noun pattern with hyphens (e.g., create-workflow, list-executions, delete-credential). All tools adhere to this convention, making them predictable and easy to parse, with no mixing of styles like camelCase or snake_case.
Tool Count3/5
With 33 tools, the count is borderline high for an MCP server, as it may feel heavy and overwhelming for agents. While n8n is a complex automation platform, the tool set could potentially be streamlined or grouped to reduce cognitive load, though it does cover a broad domain.
Completeness5/5
The tool set provides comprehensive CRUD/lifecycle coverage for all key n8n resources: workflows (activate, deactivate, create, get, update, delete, list), credentials (create, delete, get-schema), projects (create, delete, list, update), tags (create, delete, get, list, update), users (create, delete, get, list), variables (create, delete, list), and executions (delete, get, list). There are no obvious gaps, and tools like init-n8n and generate-audit add useful functionality.
Average 3.2/5 across 33 of 33 tools scored. Lowest: 2.4/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 0 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior2/5
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 states 'update' but doesn't clarify if this is a destructive operation, what permissions are needed, how errors are handled, or the response format. This is inadequate for a mutation tool with zero annotation coverage, as critical behavioral traits are missing.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's appropriately sized for a basic tool, though it could be more front-loaded with key details. There's no waste, but it lacks depth that might be needed for clarity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (a mutation tool with 3 parameters), lack of annotations, 0% schema coverage, and no output schema, the description is incomplete. It doesn't address behavioral risks, parameter meanings, or expected outcomes, leaving significant gaps for an AI agent to understand and invoke the tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate for undocumented parameters. It mentions 'tags associated with a workflow' but doesn't explain the meaning of 'clientId', 'workflowId', or 'tagIds' beyond what the schema names imply. No details on format, constraints, or relationships are added, failing to provide necessary semantic context.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Update tags associated with a workflow' clearly states the action (update) and target (workflow tags), which is better than a tautology. However, it lacks specificity about what 'update' entails (e.g., replace, add, remove) and doesn't differentiate from sibling tools like 'update-tag' or 'get-workflow-tags', making it vague in comparison.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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. For example, it doesn't specify if this should be used instead of 'update-tag' for workflow-specific operations or how it relates to 'get-workflow-tags'. The description offers no context on prerequisites, exclusions, or typical scenarios, leaving usage unclear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It states this is a creation operation, implying it's a mutation, but doesn't disclose behavioral traits like required permissions, whether it's idempotent, error conditions, or what happens on success. The description is minimal and lacks critical operational details.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence with no wasted words. It's appropriately sized for a simple tool and front-loaded with the key action. Every part of the sentence contributes to the basic purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (a mutation with 2 parameters), lack of annotations, and no output schema, the description is incomplete. It doesn't cover parameter meanings, behavioral expectations, or output details, leaving significant gaps for an AI agent to understand and invoke the tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate for undocumented parameters. It adds no meaning beyond the schema, failing to explain what 'clientId' and 'name' represent, their formats, or constraints. With 2 required parameters and no parameter info in the description, this is inadequate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states the action ('Create') and resource ('new tag'), which provides a basic purpose. However, it's vague about what a 'tag' represents in this context and doesn't differentiate from sibling tools like 'update-tag' or 'delete-tag'. The phrase 'in your instance' adds some context but remains generic.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, when not to use it, or how it relates to sibling tools like 'update-tag', 'delete-tag', or 'get-tag'. There's only an implicit context from the action 'Create'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions 'retrieve', implying a read operation, but does not address permissions, rate limits, error handling, or response format. This is inadequate for a tool with no annotation coverage, as critical behavioral traits are missing.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence with no wasted words, making it highly concise and front-loaded. It efficiently communicates the core action without unnecessary elaboration, earning full marks for brevity and structure.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (3 parameters, no annotations, no output schema), the description is incomplete. It lacks details on parameter meanings, behavioral traits, and output expectations, failing to provide sufficient context for effective tool use. This is particularly problematic as it does not compensate for the absence of structured data.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate for undocumented parameters. It only mentions 'ID' without explaining 'clientId' or 'includeData', leaving two of the three parameters (clientId and includeData) without semantic context. This fails to add meaningful information beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states the verb 'retrieve' and resource 'execution by ID', which clarifies the basic purpose. However, it lacks specificity about what an 'execution' entails (e.g., workflow execution, process run) and does not differentiate from sibling tools like 'list-executions' or 'get-workflow', making it vague in context.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives such as 'list-executions' or 'get-workflow'. The description implies usage for retrieving a specific execution by ID but offers no context on prerequisites, exclusions, or related tools, leaving the agent without clear direction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 states this is a read operation ('Get'), which implies it's non-destructive, but doesn't disclose behavioral traits such as authentication requirements, rate limits, error handling, or what happens if the workflow doesn't exist. For a tool with zero annotation coverage, this leaves significant gaps in understanding its behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with no wasted words. It's appropriately sized for a simple tool and front-loaded with the core action, making it easy to scan and understand quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (a read operation with 2 parameters), no annotations, no output schema, and low schema coverage, the description is incomplete. It doesn't explain the return format (e.g., list of tags, error cases), parameter usage, or how it differs from sibling tools, leaving the agent with insufficient context to use it effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 2 parameters (clientId and workflowId) with 0% description coverage, meaning they're undocumented in the schema. The description doesn't add any meaning beyond implying workflowId is needed, but it doesn't explain what clientId is or how these parameters relate to retrieving tags. With low schema coverage, the description fails to compensate adequately.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Get tags associated with a workflow' clearly states the verb ('Get') and resource ('tags'), but it's vague about scope and doesn't differentiate from siblings like 'get-tag' or 'list-tags'. It provides a basic purpose without specifying whether this retrieves all tags for a workflow or filters them in some way.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 like 'get-tag' (which might retrieve a single tag) or 'list-tags' (which might list all tags globally). The description implies usage for workflow-specific tags but doesn't explicitly state this or mention prerequisites like needing a workflow ID.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It states the tool 'will enable the workflow to run', implying a state change (activation), but doesn't disclose behavioral traits such as permissions required, whether activation is immediate or scheduled, error conditions (e.g., if already active), or what happens to running executions. The JSON formatting note is a behavioral constraint but limited in scope.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized with two sentences: the first states the purpose, and the second provides a critical formatting constraint. It's front-loaded with the main action. However, the second sentence could be integrated more smoothly, and there's room to add essential usage details without bloating.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations, 0% schema coverage, no output schema, and a mutation tool (activation), the description is incomplete. It lacks details on permissions, error handling, activation effects, and parameter meanings. While concise, it doesn't provide enough context for safe and effective use, especially compared to siblings like 'deactivate-workflow'.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
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 mentions 'workflow by ID', implying the 'id' parameter, and notes JSON formatting for arguments, but doesn't explain 'clientId' or provide meaning for either parameter beyond basic identification. The description adds minimal value over the bare schema, failing to clarify parameter purposes or constraints.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('activate') and resource ('workflow by ID'), specifying that it 'will enable the workflow to run'. It distinguishes from sibling 'deactivate-workflow' by implication, though not explicitly named. However, it doesn't fully differentiate from other workflow-related tools like 'update-workflow' or 'get-workflow' beyond the activation action.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., workflow must exist, be in a deactivated state), when not to use it, or compare to siblings like 'deactivate-workflow' or 'update-workflow'. The only contextual note is about JSON formatting, which is parameter-related rather than usage guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 mentions 'Create' which implies a mutation, but doesn't disclose behavioral traits like whether it requires authentication, rate limits, what happens on duplicate emails, or the format of the response. For a mutation tool with zero annotation coverage, this is a significant gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that is front-loaded with the core action. There is no wasted text, making it highly concise and well-structured for quick understanding.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of creating users (a mutation with 2 parameters), no annotations, and no output schema, the description is incomplete. It lacks details on permissions, error handling, response format, and parameter semantics, making it inadequate for safe and effective use by an AI agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
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 doesn't explain the parameters 'clientId' or 'users', their purposes, or the structure of user objects (e.g., email and role). The description adds no meaning beyond the schema, failing to address the coverage gap.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Create') and resource ('users'), specifying it can handle 'one or more users'. It distinguishes from sibling tools like 'delete-user' and 'get-user' by focusing on creation. However, it doesn't specify what 'instance' refers to, leaving some ambiguity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 doesn't mention prerequisites, such as needing admin permissions, or when to choose this over other user-related tools like 'update-user' (if it existed) or 'list-users'. The description only states what it does, not when to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 states the tool deletes an execution, implying a destructive mutation, but doesn't cover critical aspects like whether deletion is permanent, requires specific permissions, has side effects (e.g., on related data), or what happens on success/failure. This is inadequate for a mutation tool with zero annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, direct sentence with zero wasted words, making it highly concise and front-loaded. Every word ('Delete a specific execution by ID') contributes essential information, adhering perfectly to efficiency standards.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (a destructive operation with 2 parameters), lack of annotations, 0% schema coverage, and no output schema, the description is incomplete. It doesn't address behavioral risks, parameter meanings, or expected outcomes, leaving significant gaps for safe and correct tool invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 0%, meaning neither parameter (clientId, id) is documented in the schema. The description only mentions 'ID' generically, failing to clarify what 'clientId' represents or the format/scope of 'id'. It adds minimal value beyond the schema, insufficient to compensate for the coverage gap.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Delete') and the target resource ('a specific execution by ID'), making the purpose immediately understandable. However, it doesn't differentiate this tool from other deletion tools like delete-credential or delete-workflow, which would require specifying what makes an 'execution' distinct.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing execution ID), exclusions, or relationships with sibling tools like get-execution or list-executions, leaving the agent to infer usage context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. 'Delete' clearly indicates a destructive operation, but it doesn't specify permissions required, whether deletion is permanent/reversible, rate limits, or error conditions. This leaves significant gaps for a mutation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, direct sentence with zero wasted words. It's appropriately sized for a simple deletion operation and front-loads the essential information immediately.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a destructive operation with 2 undocumented parameters, no annotations, and no output schema, the description is inadequate. It doesn't address critical context like what 'clientId' means, what happens after deletion, or error scenarios, leaving the agent with insufficient information to use the tool safely.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate but fails to do so. It mentions 'ID' which corresponds to one parameter, but doesn't explain what 'clientId' represents or provide any format/validation details for either parameter. The description adds minimal value beyond the bare schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Delete') and target resource ('a tag by ID'), making the purpose immediately understandable. It doesn't distinguish from sibling tools like 'delete-project' or 'delete-workflow', but the specificity of 'tag' provides adequate differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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. While the description implies deletion of tags, it doesn't mention prerequisites (e.g., tag must exist), consequences (e.g., what happens to associated workflows), or when to use 'update-tag' instead for modification.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden for behavioral disclosure. While 'Delete' implies a destructive mutation, the description doesn't specify consequences (e.g., data loss, irreversibility), permissions required, rate limits, or what happens to associated resources. For a destructive operation with zero annotation coverage, this is inadequate.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, direct sentence with zero wasted words. It's front-loaded with the core action and resource, making it efficient and easy to parse. Every word earns its place without being overly terse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's destructive nature, 2 required parameters with 0% schema coverage, no annotations, and no output schema, the description is insufficient. It should address risks, parameter meanings, and expected outcomes. The conciseness comes at the cost of completeness for a high-stakes operation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, meaning neither parameter (clientId, idOrEmail) is documented in the schema. The description adds no information about these parameters—it doesn't explain what clientId refers to, whether idOrEmail accepts user IDs or email addresses, or their format. With 2 required parameters and no schema documentation, the description fails to compensate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Delete') and the target resource ('a user from your instance'), making the purpose immediately understandable. However, it doesn't differentiate this tool from other deletion tools like delete-credential, delete-project, or delete-workflow, which would require specifying what distinguishes user deletion from other resource deletions.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., user must exist), exclusions (e.g., cannot delete active users), or related tools like get-user for verification or create-users for reversal. With multiple sibling deletion tools, this lack of differentiation is a significant gap.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 'generate' but doesn't specify if this is a read-only operation, requires permissions, has side effects, or details output format. This is inadequate for a tool with potential security implications.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with no wasted words, making it easy to parse. It's appropriately sized for the tool's apparent complexity, though this conciseness comes at the cost of detail.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 3 parameters, 0% schema coverage, no annotations, and no output schema, the description is incomplete. It fails to explain inputs, behavioral traits, or output, making it insufficient for safe and effective use by an AI agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate but provides no parameter information. It doesn't explain what 'clientId', 'daysAbandonedWorkflow', or 'categories' mean or how they affect the audit, leaving key inputs undocumented.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('generate') and resource ('security audit for your n8n instance'), making the purpose understandable. However, it doesn't differentiate from sibling tools like 'list-executions' or 'get-workflow' that might also provide audit-related information, so it's not fully specific.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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. Given sibling tools like 'list-executions' or 'get-workflow' that might offer related data, the description lacks context on prerequisites, timing, or exclusions, leaving usage unclear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It states the tool retrieves a user but doesn't disclose behavioral traits like required permissions, error handling (e.g., if user not found), rate limits, or response format. This is a significant gap for a read operation with no annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with zero waste. It's front-loaded and appropriately sized for a simple lookup tool, making it easy for an agent to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations, 0% schema coverage, and no output schema, the description is incomplete. It lacks details on authentication, error cases, return values, and parameter meanings. For a tool with 2 required parameters and no structured documentation, this leaves the agent with insufficient context to use it effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
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 mentions 'ID or email address,' which partially explains 'idOrEmail' but doesn't clarify 'clientId' at all. With 2 parameters and no schema descriptions, the description adds minimal value beyond the parameter names, failing to fully compensate for the coverage gap.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
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 user by ID or email address.' It specifies the verb ('Get') and resource ('user'), and indicates the lookup mechanism. However, it doesn't explicitly differentiate from sibling tools like 'list-users' or 'delete-user', which would require a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'list-users' for multiple users or 'delete-user' for removal, nor does it specify prerequisites or exclusions. The agent must infer usage from the name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the action ('retrieve') and scope ('from your instance'), but lacks details on permissions required, pagination behavior (implied by 'limit' parameter but not explained), rate limits, or what the return format looks like. For a tool with 5 parameters and no annotation coverage, this is a significant gap in transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core action ('retrieve all executions') and adds qualifying details ('from your instance with optional filtering'). There is no wasted verbiage or redundancy, making it appropriately sized for its purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (5 parameters, 1 required, no annotations, no output schema), the description is incomplete. It covers the basic purpose but lacks usage guidelines, behavioral details (e.g., pagination, permissions), and parameter explanations. For a list/retrieve tool with filtering options and no structured output, more context is needed to guide effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate but adds minimal parameter semantics. It mentions 'optional filtering' which loosely relates to parameters like 'status', 'workflowId', and 'limit', but doesn't explain their purposes, relationships, or constraints (e.g., 'clientId' is required but not mentioned). With 5 parameters undocumented in both schema and description, the description fails to adequately clarify parameter meanings.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('retrieve') and resource ('executions'), and specifies the scope ('from your instance') with optional filtering. It distinguishes from sibling tools like 'get-execution' (singular) by indicating it retrieves multiple executions, though it doesn't explicitly contrast with other list tools like 'list-projects' or 'list-workflows' beyond the resource type.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It mentions optional filtering but doesn't specify scenarios for using it over other tools like 'get-execution' (for a single execution) or how it relates to siblings like 'delete-execution'. No prerequisites, exclusions, or explicit alternatives are stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool retrieves data (implying read-only), but doesn't mention any behavioral traits such as pagination (implied by the 'limit' parameter), authentication needs, rate limits, or what 'all tags' entails (e.g., if it includes archived tags). This leaves significant gaps for a tool with parameters.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose. There is no wasted language or unnecessary elaboration, making it easy to parse quickly. Every word contributes directly to understanding the tool's function.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (a read operation with 2 parameters), lack of annotations, 0% schema coverage, and no output schema, the description is incomplete. It doesn't address parameter meanings, behavioral details like pagination or sorting, or what the return data looks like. For a tool in a server with many siblings, more context is needed to use it effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds no meaning beyond what the input schema provides. With 0% schema description coverage, the two parameters ('clientId' and 'limit') are undocumented in both the schema and description. The description doesn't explain what 'clientId' refers to, how 'limit' affects results, or any default behaviors, failing to compensate for the low schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Retrieve') and resource ('all tags'), making the purpose immediately understandable. It specifies the scope ('from your instance'), which helps distinguish it from other tag-related operations. However, it doesn't explicitly differentiate from sibling tools like 'get-tag' (which likely retrieves a single tag) or 'get-workflow-tags' (which retrieves tags for a specific workflow).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'get-tag' (for single tags) or 'get-workflow-tags' (for workflow-specific tags), nor does it indicate prerequisites or typical use cases. The agent must infer usage from the tool name and context alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 states this is an update operation, implying mutation, but doesn't cover critical aspects like required permissions, whether changes are reversible, error conditions, or what the response contains. This is inadequate for a mutation tool with zero annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with no wasted words. It's front-loaded with the core purpose, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a mutation tool with 3 undocumented parameters, 0% schema description coverage, and no output schema, the description is insufficient. It should explain parameter purposes, expected outcomes, and behavioral constraints to help the agent use it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 0%, meaning none of the three parameters (clientId, id, name) are documented in the schema. The description only mentions 'name' as the attribute being updated, leaving clientId and id completely unexplained. It adds minimal value beyond what's implied by the tool name.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Update') and the resource ('a tag's name'), providing a specific verb+resource combination. However, it doesn't differentiate from sibling tools like 'update-project' or 'update-workflow', which follow similar naming patterns but operate on different resources.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing tag), exclusions, or comparisons to related tools like 'create-tag' or 'delete-tag' from the sibling list.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses that the 'active' property is read-only, which is useful behavioral context. However, it lacks details on permissions, error handling, or what happens upon creation (e.g., whether the workflow is immediately active), leaving gaps for a mutation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and front-loaded with the main purpose. The two IMPORTANT points are necessary but could be more integrated; overall, it's efficient with minimal waste.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
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, 4 parameters (2 required), 0% schema coverage, and no output schema, the description is incomplete. It misses details on parameter meanings, expected outputs, error conditions, and usage context relative to siblings, making it inadequate for safe and effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
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 mentions 'nodes' and 'connections' arrays and that 'active' should not be included, but doesn't explain the purpose or format of 'clientId' or 'name', nor does it clarify the structure of 'nodes' and 'connections'. This leaves key parameters undocumented.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Create') and resource ('new workflow in n8n'), and specifies it's for setting up workflows with optional nodes and connections. However, it doesn't explicitly differentiate from sibling tools like 'update-workflow' or 'get-workflow', which would be needed for a score of 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like 'update-workflow' or 'get-workflow', nor does it mention prerequisites or context for creation. It only includes technical formatting requirements, not usage context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must cover behavioral traits. It states the effect ('prevent the workflow from running') and a formatting requirement for arguments, but lacks details on permissions, reversibility, side effects, or error handling, which are critical for a mutation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences: one for the core action and effect, one for a technical requirement. It's front-loaded with the main purpose, though the second sentence could be integrated more smoothly. No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
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, no output schema, and 0% schema coverage, the description is incomplete. It misses key details like what 'deactivate' entails operationally, success/error responses, and how it differs from other workflow modifications, leaving gaps for agent understanding.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description should compensate. It mentions 'ID' but not 'clientId', and adds a formatting constraint for arguments ('compact, single-line JSON'), which provides some value beyond the bare schema. However, it doesn't fully explain both parameters' purposes.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('deactivate') and resource ('workflow by ID'), with the effect 'prevent the workflow from running'. It distinguishes from sibling 'activate-workflow' by specifying deactivation, though not explicitly contrasting with other workflow tools like 'delete-workflow' or 'update-workflow'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 'delete-workflow' or 'update-workflow', nor prerequisites such as workflow state. The description only mentions the action without context for selection among siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden but only states it retrieves a tag without disclosing behavioral traits like permissions needed, error handling, or response format. It mentions 'by ID' which adds some context but lacks details on what happens if the ID is invalid or if authentication is required.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the key action and resource. There is no wasted text, making it appropriately sized for its purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (a read operation with 2 required parameters), no annotations, and no output schema, the description is incomplete. It doesn't explain what the tool returns, error conditions, or how parameters interact, leaving significant gaps for an AI agent to understand usage fully.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate but only implies 'ID' as a parameter without explaining 'clientId'. It adds minimal meaning beyond the schema, which documents two required string parameters but without descriptions. Baseline is 3 due to low coverage and partial compensation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Retrieve') and resource ('a specific tag'), making the purpose evident. However, it doesn't differentiate from sibling tools like 'list-tags' or 'get-workflow-tags', which would require specifying it fetches a single tag by ID rather than multiple tags.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives such as 'list-tags' for multiple tags or 'get-workflow-tags' for workflow-related tags. The description implies usage by ID but doesn't explicitly state prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 mentions the ownership requirement, which is a behavioral trait, but fails to disclose critical details: whether the deletion is permanent or reversible, if there are rate limits, what happens to associated data, or what the response looks like (e.g., success/failure messages). For a destructive operation with zero annotation coverage, this is inadequate.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise with two sentences that directly convey the core action and a key constraint. Every word earns its place, and it's front-loaded with the primary purpose. No unnecessary information or redundancy is present.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (a destructive delete operation), lack of annotations, 0% schema coverage, and no output schema, the description is incomplete. It misses critical context such as parameter details, behavioral implications (e.g., permanence), and response format, making it insufficient for safe and effective use by an AI agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate for two undocumented parameters. It only mentions 'ID' (likely corresponding to the 'id' parameter) but omits 'clientId' entirely. No details on parameter formats, constraints, or examples are provided, leaving significant gaps in understanding.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Delete') and resource ('credential by ID'), making the purpose unambiguous. It distinguishes from siblings like 'delete-project' or 'delete-user' by specifying the credential resource type. However, it doesn't explicitly contrast with similar tools like 'delete-execution' or 'delete-workflow' beyond the resource name.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides one usage guideline: 'You must be the owner of the credentials.' This implies a permission requirement but doesn't specify when to use this tool versus alternatives like 'delete-project' or 'delete-user', nor does it mention prerequisites beyond ownership. No explicit alternatives or exclusions are stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the ownership restriction, which is useful context, but fails to describe other critical behaviors: it doesn't specify whether this is a read-only operation (though 'Retrieve' implies it), what the return format looks like (e.g., list structure, pagination), or any rate limits or side effects. For a tool with no annotation coverage, this leaves significant gaps in understanding how it behaves.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise—two short sentences that directly convey the core purpose and a key constraint. Every word earns its place, with no redundant or vague language. It's front-loaded with the main action ('Retrieve all users'), making it easy to scan and understand quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (a retrieval operation with access restrictions), lack of annotations, no output schema, and incomplete parameter documentation, the description is insufficient. It covers the 'what' and a usage limit but omits critical details: parameter semantics, return format, error handling, and behavioral traits like idempotency or side effects. For a tool in this context, more completeness is needed to guide effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 1 parameter ('clientId') with 0% description coverage, meaning the schema provides no semantic information. The description adds no details about this parameter—it doesn't explain what 'clientId' represents, how to obtain it, or its role in the retrieval process. With low schema coverage, the description fails to compensate, leaving the parameter's meaning unclear.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Retrieve') and resource ('all users from your instance'), making the purpose specific and understandable. It doesn't explicitly distinguish from sibling tools like 'get-user' (singular) or 'create-users', but the scope ('all users') provides implicit differentiation. The description avoids tautology by adding meaningful detail beyond the tool name.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description includes a usage constraint ('Only available for the instance owner'), which provides important context for when this tool can be used. However, it doesn't offer explicit guidance on when to choose this tool over alternatives like 'get-user' (for a single user) or 'create-users', nor does it mention any prerequisites beyond ownership. The guidance is implied rather than comprehensive.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It reveals that this is a destructive operation ('Delete'), mentions license requirements, and specifies input format constraints ('Arguments must be provided as compact, single-line JSON'). However, it doesn't describe what happens after deletion (e.g., irreversible, cascading effects), error conditions, or response format, leaving significant behavioral gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized with three sentences that each serve a purpose: stating the action, noting license requirements, and specifying input format. It's front-loaded with the core purpose. While efficient, the third sentence about JSON formatting could be slightly more concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
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, 0% schema coverage, and no output schema, the description is insufficiently complete. It lacks critical information: what 'Delete' entails (irreversible? cascading?), the meaning of parameters, error handling, and response format. The license and input format notes are helpful but don't compensate for these major gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 0%, meaning neither parameter (clientId, projectId) is documented in the schema. The description mentions 'project by ID' which hints at projectId but doesn't explain clientId at all. It adds minimal semantic value beyond what the parameter names suggest, failing to compensate for the complete lack of schema documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Delete') and resource ('a project by ID'), making the purpose immediately understandable. It distinguishes from siblings like 'delete-workflow' or 'delete-user' by specifying the project resource. However, it doesn't explicitly differentiate from 'delete-execution' or other deletion tools beyond the resource name.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides some usage context by stating license requirements ('Requires n8n Enterprise license with project management features enabled'), which helps determine when the tool is available. However, it doesn't explicitly say when to use this tool versus alternatives like 'delete-workflow' or provide guidance on prerequisites beyond licensing.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses important behavioral traits: the licensing requirement and the JSON formatting constraint ('Arguments must be provided as compact, single-line JSON'). However, it doesn't cover other aspects like error handling, response format, or side effects, leaving gaps for a mutation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized with two sentences: one for the core purpose and prerequisites, and another for technical constraints. It's front-loaded with the main action. While efficient, the second sentence could be more integrated, but overall it earns its place without waste.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (a creation tool with licensing requirements), no annotations, no output schema, and poor parameter documentation, the description is incomplete. It covers licensing and formatting but misses parameter details, expected outputs, and error scenarios. It's minimally adequate but with clear gaps for effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0% description coverage, with two required parameters (clientId and name) undocumented. The description adds no meaning about what these parameters represent, their formats, or examples. It only mentions JSON formatting generally, failing to compensate for the schema gap, resulting in a low score.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Create' and the resource 'new project in n8n', making the purpose explicit. It distinguishes from siblings like 'update-project' or 'delete-project' by specifying creation. However, it doesn't explicitly differentiate from 'create-workflow' or 'create-credential' beyond the resource type, keeping it at 4 rather than 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
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: 'Requires n8n Enterprise license with project management features enabled' establishes prerequisites. It implies usage for project creation versus alternatives like 'update-project' or 'list-projects', but doesn't explicitly state when-not-to-use or name specific alternatives, so it scores 4.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
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 useful context about licensing requirements and input formatting ('Arguments must be provided as compact, single-line JSON'), but it doesn't cover other behavioral aspects like error handling, response format, or side effects, leaving gaps for a mutation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized with two sentences: the first states the purpose and prerequisites, and the second provides critical formatting instructions. It's front-loaded with essential information, though the formatting note could be integrated more smoothly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (a mutation with 3 required parameters), no annotations, and no output schema, the description is incomplete. It covers licensing and formatting but misses details on parameters, return values, and potential errors, making it adequate but with clear gaps for effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 0%, so the description must compensate for undocumented parameters. It only mentions 'name' as updatable, implying the purpose of that parameter, but doesn't explain 'clientId' or 'projectId' (e.g., their roles in identifying the project). This partial coverage is insufficient given the low schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Update') and resource ('a project's name'), making the purpose specific and understandable. However, it doesn't explicitly distinguish this tool from its sibling 'update-workflow' or other update tools, which would be needed for a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
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 by stating 'Requires n8n Enterprise license with project management features enabled', which acts as a prerequisite. It doesn't mention alternatives like 'create-project' for new projects or exclusions, so it falls short of a perfect score.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It discloses that this is a mutation tool ('Update'), mentions a behavioral constraint ('Arguments must be provided as compact, single-line JSON without whitespace or newlines'), and implies it modifies existing data. However, it lacks critical details: no information about permissions required, whether changes are reversible, error handling, or what the response contains. For a mutation tool with 3 parameters and no annotations, this is insufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with core purpose, followed by an important behavioral note. Zero waste: every sentence provides essential information (usage context and input format constraint).
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given complexity (mutation tool, 3 parameters with nested objects, 0% schema coverage, no annotations, no output schema), the description is incomplete. It covers purpose and a format constraint but lacks details on parameter meanings, behavioral traits (e.g., side effects, permissions), and expected outcomes. For a tool that modifies workflows, this leaves significant gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the schema provides no parameter descriptions. The description adds some value by implying 'workflow' parameter includes properties, nodes, or connections to modify, and notes the JSON format requirement. However, it doesn't explain the semantics of clientId, id, or the nested workflow object fields (name, active, nodes, connections, settings), leaving most parameters undocumented.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Update') and resource ('an existing workflow in n8n'), and specifies what can be modified ('workflow's properties, nodes, or connections'). It distinguishes from create-workflow by mentioning 'existing workflow' and referencing get-workflow, but doesn't explicitly contrast with update-project or update-tag among siblings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It provides clear context: 'Use after get-workflow to modify a workflow's properties, nodes, or connections.' This gives a specific prerequisite (get-workflow) and scope of modification. However, it doesn't explicitly state when NOT to use it (e.g., vs. create-workflow or deactivate-workflow) or name alternatives among siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It mentions the JSON formatting requirement ('compact, single-line JSON without whitespace or newlines'), which is useful behavioral context. However, it doesn't disclose other important traits like authentication needs, rate limits, error behavior, or what 'detailed information' includes in the response.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is perfectly concise with two sentences: one stating the purpose and usage guideline, another providing critical formatting instruction. Every sentence earns its place with no wasted words, and important information is front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 2 required parameters, 0% schema coverage, no annotations, and no output schema, the description provides basic purpose and usage guidance but lacks parameter explanations and behavioral details. It's minimally adequate for a simple retrieval tool but leaves significant gaps in understanding parameter meanings and response format.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
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 mentions 'ID' but doesn't explain what 'clientId' represents or provide any context about parameter formats, sources, or constraints. The description adds minimal value beyond what the bare schema provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'retrieve' and resource 'workflow by ID', making the purpose specific and understandable. However, it doesn't explicitly differentiate from sibling tools like 'get-execution' or 'get-user', which follow similar patterns for different resources.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance: 'Use after list-workflows to get detailed information about a specific workflow.' This clearly indicates when to use this tool versus its sibling 'list-workflows', establishing a sequential workflow pattern.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
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 important context about license requirements and input format constraints ('Arguments must be provided as compact, single-line JSON'), which goes beyond basic functionality. However, it doesn't describe what the tool returns, pagination behavior, error conditions, or other operational characteristics that would be helpful for an agent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise with only two sentences, both of which provide essential information. The first sentence states the core purpose, and the second provides critical prerequisites and formatting requirements. Every word earns its place with no wasted text.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (list operation with license requirements), no annotations, no output schema, and poor parameter documentation, the description does an adequate but incomplete job. It covers the license prerequisite well but leaves the parameter meaning, return format, and operational behavior unspecified, which creates gaps for an agent trying to use this tool effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage and one required parameter (clientId), the description provides no information about what clientId represents, its format, or its purpose. The schema only indicates it's a required string, so the description fails to compensate for the complete lack of parameter documentation in the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('List') and resource ('all projects from n8n'), making the purpose immediately understandable. However, it doesn't differentiate this tool from other list operations like list-executions or list-workflows, which would require mentioning what makes projects distinct from those other resources.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit prerequisites ('Requires n8n Enterprise license with project management features enabled'), which is excellent guidance on when this tool can be used. It doesn't mention when to use alternatives or compare it to other list operations, but the license requirement provides clear context for usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
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 effectively communicates the destructive nature ('This action cannot be undone') and provides important implementation guidance about argument formatting. However, it doesn't mention authentication requirements, rate limits, or what happens to dependent resources when a workflow is deleted.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely efficient with two sentences that each serve distinct purposes: the first states the core functionality, the second provides critical implementation guidance. There's zero wasted language, and the most important information (the irreversible deletion) is front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a destructive operation with no annotations and no output schema, the description does well on behavioral warnings but poorly on parameter documentation. The irreversibility warning is crucial, but the complete lack of parameter semantics and absence of information about return values or error conditions leaves significant gaps for a tool that permanently deletes resources.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage for both parameters, the description provides no information about what 'clientId' or 'id' represent, their expected formats, or how they relate to workflow deletion. The description mentions 'ID' generally but doesn't clarify which parameter corresponds to the workflow ID versus client ID.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Delete') and resource ('a workflow by ID'), distinguishing it from sibling tools like 'deactivate-workflow' or 'delete-project'. It provides a precise verb+resource combination that leaves no ambiguity about what the tool does.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like 'deactivate-workflow' or 'delete-execution'. While it warns about irreversibility, it doesn't specify prerequisites, conditions, or contextual factors that should influence tool selection among the many deletion-related siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
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 mentions that arguments must be provided as compact JSON, which is a useful behavioral constraint not covered elsewhere. However, it lacks details on permissions, rate limits, pagination, or what the output looks like, leaving gaps for a tool with no annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and front-loaded, with two sentences that efficiently convey purpose, usage, and a critical formatting requirement. Every sentence adds value without unnecessary elaboration, making it easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has no annotations, no output schema, and low parameter coverage, the description is incomplete. It covers usage timing and argument format but misses essential details like return values, error handling, or behavioral traits, which are crucial for effective tool invocation in this context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 1 parameter with 0% description coverage, and the description does not explain what 'clientId' means or how it should be used. It only specifies the format for arguments (compact JSON), which adds minimal semantic value beyond the schema's structural information.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('List') and resource ('all workflows from n8n'), making the purpose specific and understandable. However, it does not explicitly differentiate from sibling tools like 'get-workflow' or 'list-executions', which would require mentioning it retrieves multiple workflows without filtering details.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit usage guidance by stating 'Use after init-n8n to see available workflows,' indicating a prerequisite and timing. It also implies an alternative context for viewing workflows, though it does not name specific sibling alternatives, the guidance 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.
Behavior3/5
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 licensing requirements and technical constraints for arguments, which are useful behavioral traits. However, it does not cover other aspects like rate limits, error handling, or output format, leaving gaps for a tool with no annotations. This is adequate but incomplete.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core purpose, followed by prerequisites and technical details in a concise manner. Each sentence adds necessary information without redundancy, making it efficient and well-structured for quick understanding.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations, no output schema, and low schema coverage, the description provides good usage guidelines and some behavioral context but lacks details on parameters and output. It is partially complete, suitable for a simple list tool but could be improved with parameter explanations or output hints.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 1 parameter with 0% description coverage, and the description does not explain the 'clientId' parameter's meaning, purpose, or format. It only mentions argument formatting in general. Since schema coverage is low, the description fails to compensate for the undocumented parameter, adding minimal value beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'List all variables from n8n.' It specifies the resource (variables) and the action (list), but does not explicitly differentiate it from sibling tools like 'get-variable' or 'create-variable' beyond the 'list' verb, which is implied by the name. This makes it clear but not fully distinct from siblings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit usage guidelines: it states prerequisites ('Requires n8n Enterprise license with variable management features enabled'), references a sibling tool for setup ('Use after init-n8n to see available variables'), and includes a technical requirement ('Arguments must be provided as compact, single-line JSON without whitespace or newlines'). This covers when to use and important constraints effectively.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
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 this establishes a connection, which implies it's a setup/mutation operation (though not explicitly stated as destructive). It doesn't mention authentication requirements beyond needing URL and API key, rate limits, or what happens on failure. The description adds some context about argument format requirements, which is useful behavioral information.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise and well-structured. The first sentence states the purpose, the second provides usage guidance, and the third gives critical formatting requirements. Every sentence earns its place with no wasted words, and the most important information (the tool's function) is front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given this is a 2-parameter initialization tool with no annotations and no output schema, the description does an adequate job. It explains what the tool does and when to use it, but doesn't cover what happens after initialization (e.g., does it return a session token?), error conditions, or prerequisites. For a connection tool, more detail about the expected outcome would be helpful.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
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. While it doesn't explicitly name the parameters, it clearly indicates that 'n8n URL and API key' are needed, which maps directly to the 'url' and 'apiKey' parameters in the schema. The description adds important semantic context about what these parameters represent (connection credentials) that the bare schema doesn't provide.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Initialize connection to n8n instance.' It specifies the verb ('Initialize') and resource ('connection to n8n instance'), making it clear this is an initialization/connection tool. However, it doesn't explicitly differentiate from siblings like 'activate-workflow' or 'create-credential', which are distinct operations rather than connection setup.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear usage context: 'Use this tool whenever an n8n URL and API key are shared to establish the connection.' This gives explicit guidance on when to use it (when credentials are available). It doesn't specify when NOT to use it or name alternatives, but the context implies this is a prerequisite for other operations, which is helpful.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
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 mentions that credentials are 'used by nodes of the specified type,' implying integration with workflows, but lacks details on permissions needed, whether creation is idempotent, error handling, or response format. This leaves gaps for a mutation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core purpose in the first sentence, followed by a practical example and a prerequisite step. Each sentence adds value without redundancy, making it efficient and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations, 0% schema coverage, no output schema, and a mutation tool with nested objects, the description is incomplete. It covers purpose and usage well but lacks details on behavioral traits, full parameter semantics, and expected outcomes, leaving significant gaps for effective tool invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate for undocumented parameters. It explains 'type' with examples (e.g., 'cloudflareApi') and hints that 'data' contains required fields from get-credential-schema, but does not clarify 'clientId' or 'name' parameters. This partial coverage is insufficient for a tool with 4 required parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Create a credential') and resource ('that can be used by nodes of the specified type'), distinguishing it from siblings like delete-credential or get-credential-schema. It provides concrete examples of credential types (e.g., 'cloudflareApi', 'githubApi'), 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.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states when to use this tool ('Create a credential') and when to use an alternative ('Use get-credential-schema first to see what fields are required'), providing clear guidance on prerequisites and distinguishing it from sibling tools like get-credential-schema.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
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 describes the tool as informational ('Show credential data schema'), implying a read-only operation, but does not detail aspects like error handling, response format, or any limitations. It adds some context about credential type sources but lacks comprehensive behavioral traits.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and front-loaded, with two sentences that efficiently convey purpose and usage without wasted words. Every sentence adds value: the first states the core function, and the second provides practical guidance with examples.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (2 parameters, no output schema, no annotations), the description is somewhat complete but has gaps. It covers the tool's purpose and usage well, but lacks details on behavioral aspects like response format or error conditions, which are important for a schema-retrieval tool with no structured output documentation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0% description coverage, so the description must compensate. It explains the meaning of 'credentialTypeName' with examples (e.g., 'cloudflareApi'), but does not clarify 'clientId'. Since there are only 2 parameters and the description partially covers one, it adds moderate value beyond the bare schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with a specific verb ('Show') and resource ('credential data schema'), and distinguishes it from siblings like 'create-credential' by focusing on schema retrieval rather than creation. It explicitly mentions what the tool does: displaying required fields for credential creation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context on when to use this tool: when needing to know required fields for creating credentials of a specific type. It includes a practical example of credential type names from the n8n UI, but does not explicitly state when not to use it or name alternatives among siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
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 effectively communicates key behavioral traits: the licensing requirement (access control), the purpose of variables ('used across workflows to store and share data'), and a critical implementation detail about argument formatting ('compact, single-line JSON without whitespace or newlines'). This provides substantial value beyond basic function description.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is efficiently structured with three sentences that each serve distinct purposes: stating the core function, providing licensing requirements and variable purpose, and giving critical formatting instructions. There's no wasted language, and important information is front-loaded appropriately.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a creation tool with no annotations and no output schema, the description does well by covering licensing requirements, variable purpose, and critical formatting constraints. However, it doesn't explain what happens on success/failure, whether the operation is idempotent, or provide examples of the compact JSON format. Given the complexity of a creation operation, there are some gaps in completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage for 3 required parameters, the description doesn't explain what 'clientId', 'key', or 'value' represent or how they should be formatted beyond the JSON requirement. While it mentions arguments must be compact JSON, it doesn't add semantic meaning to the individual parameters. The baseline is appropriate given the schema's lack of descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Create a new variable'), target resource ('in n8n'), and distinguishes it from siblings like 'list-variables' and 'delete-variable' by focusing on creation rather than retrieval or removal. It provides a clear verb+resource combination with contextual differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states when to use this tool ('Create a new variable in n8n') and includes important prerequisites ('Requires n8n Enterprise license with variable management features enabled'). However, it doesn't explicitly mention when NOT to use it or name specific alternatives among siblings, though the context implies it's for creation rather than listing or deleting variables.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
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 successfully describes critical behavioral traits: the irreversible nature of the operation ('This action cannot be undone'), specific licensing requirements ('Requires n8n Enterprise license'), and input format constraints ('Arguments must be provided as compact, single-line JSON without whitespace or newlines'). This covers safety, prerequisites, and technical constraints.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is perfectly structured and front-loaded with the core purpose, followed by important notes in logical order (prerequisites, usage guidance, warnings, technical requirements). Every sentence earns its place with critical information, and there's zero wasted text or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
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 does an excellent job covering behavioral aspects (irreversible, licensing, input format) and usage guidance. The main gap is incomplete parameter documentation (only explains 'id', not 'clientId'), which prevents a perfect score despite otherwise comprehensive coverage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
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. It explains that the 'id' parameter refers to 'the ID of the variable to delete' and implies it should come from 'list-variables'. However, it doesn't explain the 'clientId' parameter at all. The description adds meaningful context for one parameter but leaves the other undocumented.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Delete a variable by ID') with the exact resource ('variable'), distinguishing it from sibling tools like 'delete-workflow', 'delete-user', or 'delete-tag' that target different resources. It uses precise language that leaves no ambiguity about what the tool does.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance on when to use this tool ('Use after list-variables to get the ID of the variable to delete') and mentions prerequisites ('Requires n8n Enterprise license with variable management features enabled'). It also clearly states when NOT to use it ('This action cannot be undone'), providing complete usage context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![n8n-mcp-server MCP server](https://glama.ai/mcp/servers/illuminaresolutions/n8n-mcp-server/badges/card.svg)](https://glama.ai/mcp/servers/illuminaresolutions/n8n-mcp-server)

Score Badge

Copy to your README.md:

[![n8n-mcp-server MCP server](https://glama.ai/mcp/servers/illuminaresolutions/n8n-mcp-server/badges/score.svg)](https://glama.ai/mcp/servers/illuminaresolutions/n8n-mcp-server)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/illuminaresolutions/n8n-mcp-server'

If you have feedback or need assistance with the MCP directory API, please join our Discord server