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 activation enables the workflow to run, but lacks details on permissions, side effects, rate limits, or response behavior, leaving 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.

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

The description is front-loaded with the core purpose and includes a critical formatting requirement in two concise sentences, with no redundant information, making it highly efficient.

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

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

For a mutation tool with no annotations, no output schema, and low schema coverage, the description is incomplete. It lacks details on behavioral traits, error handling, and output expectations, which are essential for safe and effective use.

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

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

Schema description coverage is 0%, so the description must compensate. It adds that arguments must be provided as compact JSON, which clarifies formatting, but does not explain the meaning of 'clientId' or 'id' parameters beyond what the schema provides.

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

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

The description clearly states the verb ('activate') and resource ('workflow by ID'), specifying that it enables the workflow to run. However, it does not explicitly differentiate from its sibling 'deactivate-workflow', though the contrast is implied.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'deactivate-workflow' or 'update-workflow', nor does it mention prerequisites or contextual factors such as workflow state or permissions.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states this is a creation tool, implying mutation, but doesn't describe permissions needed, whether credentials are immediately usable, error handling, or what the response looks like. For a mutation tool with zero annotation coverage, this is a significant gap, though it does mention credential types and references another tool for schema details.

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

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

The description is appropriately sized with two sentences that are front-loaded: the first states the purpose, and the second provides usage guidance. There's no wasted text, and each sentence adds value, though it could be slightly more structured (e.g., bullet points for parameters).

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

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

Given the complexity (mutation tool with 4 parameters, 0% schema coverage, no output schema, and no annotations), the description is incomplete. It lacks details on behavioral traits, full parameter explanations, and output expectations. While it references 'get-credential-schema' for field requirements, this doesn't fully compensate for the gaps in a creation tool context.

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

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

Schema description coverage is 0%, so the description must compensate for undocumented parameters. It mentions 'credential type name' (mapping to 'type') and 'fields are required' (hinting at 'data'), but doesn't explain 'clientId' or 'name' parameters. The description adds some meaning but doesn't fully compensate for the coverage gap, especially with 4 parameters and nested objects in 'data'.

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

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

The description clearly states the tool's purpose: 'Create a credential that can be used by nodes of the specified type.' It specifies the verb ('create') and resource ('credential'), and distinguishes it from siblings like 'delete-credential' and 'get-credential-schema' by focusing on creation. However, it doesn't explicitly differentiate from other creation tools (e.g., 'create-project'), making it a 4 rather than a 5.

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

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

The description provides clear context for when to use this tool: 'Use get-credential-schema first to see what fields are required for the credential type you want to create.' This explicitly names an alternative tool and gives a prerequisite step. However, it doesn't specify when NOT to use it (e.g., vs. updating credentials) or mention other alternatives, so it's a 4.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively adds critical context: the licensing requirement (which implies access control) and the strict input format requirement ('Arguments must be provided as compact, single-line JSON'). This goes beyond the basic 'create' action, though it doesn't cover aspects like error handling or response format.

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

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

The description is highly concise and front-loaded: it states the core purpose first, followed by two critical notes. Every sentence adds essential information (creation action, licensing requirement, input format), with zero wasted words, making it efficient and easy to parse.

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

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

Given the complexity (a creation tool with licensing constraints), no annotations, no output schema, and low schema coverage, the description is moderately complete. It covers key behavioral aspects but lacks parameter details and output information, leaving gaps that could hinder correct tool invocation in some scenarios.

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

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

The input schema has 0% description coverage, and the tool description provides no information about the parameters 'clientId' and 'name'. While it mentions the JSON format requirement, it doesn't explain what these parameters represent, their expected values, or any constraints, failing to compensate for the schema's lack of documentation.

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

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

The description clearly states the action ('Create a new project') and the target system ('in n8n'), which is specific and unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'update-project' or 'delete-project' beyond the verb 'create', missing a direct comparison that would warrant 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.

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 helpful context. However, it lacks guidance on when to use this tool versus alternatives like 'update-project' or 'list-projects', and doesn't mention any exclusions or complementary tools, leaving usage context partially implied.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. While 'Create' implies a write/mutation operation, the description doesn't disclose what permissions are needed, whether the operation is idempotent, what happens on duplicate names, or what the response looks like. For a mutation tool with zero annotation coverage, this leaves 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.

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

The description is a single, efficient sentence with zero waste. It's appropriately sized for a simple creation operation and gets straight to the point without unnecessary elaboration.

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

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

For a mutation tool with no annotations, no output schema, and 2 undocumented parameters, the description is insufficient. It doesn't explain what a 'tag' is in this system, what the creation entails, or what happens after creation. The agent lacks critical context to use this tool effectively.

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

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

With 0% schema description coverage and 2 required parameters, the description provides no information about what 'clientId' and 'name' represent, their formats, constraints, or relationships. The description doesn't compensate for the complete lack of schema documentation, leaving both parameters semantically undefined.

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

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

The description clearly states the action ('Create') and resource ('a new tag in your instance'), providing a specific verb+resource combination. However, it doesn't differentiate this tool from its sibling 'update-tag' or explain what distinguishes tag creation from other creation operations like 'create-project' or 'create-workflow'.

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

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

The description provides no guidance on when to use this tool versus alternatives. There's no mention of prerequisites, when-not-to-use scenarios, or comparison with sibling tools like 'update-tag' or 'get-tag'. The agent must infer usage context from the tool name alone.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool creates users but lacks critical details: it doesn't specify required permissions, whether creation is idempotent, what happens on failure (e.g., partial creation), rate limits, or the format of the response. For a mutation tool with zero 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.

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

The description is a single, efficient sentence that front-loads the core purpose ('Create one or more users') and specifies the scope ('in your instance'). There is no wasted verbiage, making it highly concise and well-structured for quick comprehension.

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

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

Given the tool's complexity (a mutation with 2 required parameters, no annotations, and no output schema), the description is incomplete. It lacks details on behavioral traits, parameter meanings, error handling, and output expectations. For a user creation tool in a system with multiple sibling tools, 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.

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 creating 'users' but provides no semantic details about the two required parameters ('clientId' and 'users') or their nested structure (e.g., what 'email' and 'role' entail). The description adds minimal value beyond the schema, failing to explain parameter purposes or constraints.

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

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

The description clearly states the action ('Create') and resource ('users in your instance'), specifying it can handle 'one or more users'. It distinguishes from sibling tools like 'delete-user' and 'get-user' by focusing on creation rather than deletion or retrieval. However, it doesn't explicitly differentiate from other creation tools like 'create-project' or 'create-workflow' 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.

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 admin permissions), when not to use it (e.g., for updating existing users), or direct alternatives among siblings like 'update-project' for modifying resources. Usage is implied only by the verb 'Create'.

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

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

With no annotations provided, the description carries the full burden. It discloses licensing requirements and data format constraints (compact JSON), which are useful behavioral traits. However, it doesn't cover other important aspects like error handling, permissions needed beyond licensing, whether the operation is idempotent, or what happens on duplicate keys. The description adds some value but 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.

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

The description is appropriately sized with three sentences. The first states the purpose, the second adds licensing and use context, and the third provides critical formatting instructions. It's front-loaded with the core action. However, the licensing note could be integrated more smoothly.

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

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

Given a mutation tool with 3 parameters (0% schema coverage), no annotations, and no output schema, the description is incomplete. It misses parameter explanations, error conditions, response format, and detailed behavioral context. The licensing and formatting notes are helpful but don't compensate for the overall gaps in a creation operation.

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

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

Schema description coverage is 0%, so the description must compensate. It doesn't explain what 'clientId', 'key', or 'value' represent, their formats, or constraints. The note about compact JSON applies to arguments generally but doesn't clarify individual parameters. For a tool with 3 required parameters and no schema descriptions, this is inadequate.

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

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

The description clearly states the verb ('Create') and resource ('new variable in n8n'), making the purpose unambiguous. It distinguishes from siblings like 'delete-variable' and 'list-variables' by specifying creation. However, it doesn't explicitly differentiate from other creation tools like 'create-workflow' or 'create-project' in terms of when to choose one over another.

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

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

The description provides some context with the note about requiring an n8n Enterprise license, which implies when NOT to use it (without proper licensing). It mentions variables can be used across workflows, giving a hint about use cases. However, it lacks explicit alternatives (e.g., when to use this vs. other storage methods) or clear prerequisites beyond licensing.

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

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

With no annotations provided, the description carries full burden. It discloses important behavioral traits: JSON formatting requirements, mandatory structure elements (nodes/connections arrays), and read-only property exclusion. However, it doesn't cover permissions, error conditions, or response format, 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.

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

The description is appropriately sized and front-loaded with the core purpose. The two IMPORTANT points are necessary for correct usage, though the second point could be more concise. No wasted sentences, but minor structural improvements possible.

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

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

For a 4-parameter mutation tool with no annotations and no output schema, the description provides adequate technical constraints but lacks completeness. It covers JSON formatting and structure requirements well, but doesn't explain what happens after creation, error handling, or relationship to other tools like 'activate-workflow'.

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

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

With 0% schema description coverage for 4 parameters, the description compensates well by explaining that 'nodes' and 'connections' must be provided as arrays/objects (even if empty), and that 'active' property should be excluded. It doesn't detail 'clientId' or 'name' semantics, but provides crucial structural guidance missing from the schema.

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

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

The description clearly states the action ('Create a new workflow') and resource ('in n8n'), with additional context about optional nodes and connections. It distinguishes from siblings like 'update-workflow' or 'get-workflow' by focusing on creation, though it doesn't explicitly compare to all siblings.

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

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

The description implies usage for setting up new workflows, but doesn't explicitly state when to use this versus alternatives like 'init-n8n' or 'update-workflow'. It provides technical requirements (JSON format, structure) but lacks contextual guidance on prerequisites or typical scenarios.

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

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

With no annotations provided, the description carries full burden. It discloses that deactivation prevents running (a key behavioral trait) and notes a critical formatting constraint for arguments. However, it lacks details on permissions needed, reversibility, effects on related entities, or error conditions.

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

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

The description is front-loaded with the core purpose, followed by a critical formatting note. Both sentences are essential—no fluff—making it highly efficient and well-structured for quick comprehension.

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

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

Given no annotations, 0% schema coverage, and no output schema, the description is incomplete. It covers the action and a formatting rule but misses parameter semantics, behavioral details like side effects, and expected outcomes, which are crucial for a mutation tool.

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

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

Schema description coverage is 0%, so the description must compensate. It does not explain what 'clientId' or 'id' represent, their formats, or examples. The mention of JSON formatting adds some value but does not clarify parameter meanings beyond the schema.

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

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

The description clearly states the action ('deactivate') and resource ('workflow by ID'), specifying that it prevents the workflow from running. It distinguishes from sibling 'activate-workflow' by indicating the opposite action, though not explicitly naming the alternative.

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

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

The description implies usage when needing to stop a workflow from running, but does not explicitly state when to use this vs. alternatives like 'delete-workflow' or provide prerequisites. It mentions an important formatting requirement, which offers some contextual guidance.

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

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

No annotations are provided, so the description carries the full burden. It mentions ownership requirement but lacks details on permissions, whether deletion is permanent/reversible, error handling, or rate limits. For a destructive tool, this leaves 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.

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

The description is front-loaded and efficient with two concise sentences that directly address purpose and prerequisite. Every word contributes essential information without redundancy or fluff.

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

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

Given the tool's destructive nature, lack of annotations, 0% schema coverage, and no output schema, the description is incomplete. It misses critical details like return values, error conditions, and full parameter explanations, leaving the agent under-informed.

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

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

Schema description coverage is 0%, so the description must compensate. It only mentions 'ID' without specifying which parameter (clientId or id) corresponds to the credential ID or explaining their purposes. This adds minimal value beyond the schema.

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

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

The description clearly states the specific action ('Delete') and resource ('a credential by ID'), distinguishing it from siblings like 'create-credential' or 'delete-project'. It precisely communicates what the tool does without ambiguity.

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

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

The description provides clear context for usage with 'You must be the owner of the credentials', indicating a prerequisite. However, it does not explicitly state when to use this versus alternatives like 'delete-project' or 'delete-workflow', nor does it mention exclusions or edge cases.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool deletes an execution, implying a destructive mutation, but lacks details on permissions required, whether deletion is reversible, error handling (e.g., invalid ID), or side effects. 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.

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

The description is a single, direct sentence with no wasted words, making it highly concise and front-loaded. Every word contributes to stating the tool's purpose efficiently, which is appropriate for such a straightforward action.

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

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

Given the tool's complexity (a destructive mutation), lack of annotations, no output schema, and incomplete parameter documentation, the description is insufficient. It doesn't cover critical aspects like behavioral traits, return values, or full parameter meanings, leaving the agent poorly equipped to use it correctly.

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

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

The input schema has 2 parameters with 0% description coverage, so the schema provides no semantic context. The description mentions 'by ID' but doesn't clarify what 'ID' refers to (e.g., execution ID) or explain the 'clientId' parameter at all. It adds minimal value beyond the schema, failing to compensate for the coverage gap.

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

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

The description clearly states the action ('Delete') and the target resource ('a specific execution by ID'), making the purpose unambiguous. However, it doesn't differentiate from sibling tools like 'delete-workflow' or 'delete-project', which follow the same pattern, so it doesn't fully distinguish itself within the toolset.

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

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

The description provides no guidance on when to use this tool versus alternatives. With sibling tools like 'get-execution' and 'list-executions' available, there's no indication of prerequisites (e.g., needing to retrieve an execution first) or exclusions (e.g., not for active executions). This leaves the agent without context for proper selection.

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

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

No annotations are provided, so the description carries the full burden. It discloses the license requirement and input format constraint ('compact, single-line JSON'), which are useful behavioral traits. However, it lacks details on destructive effects (e.g., irreversible deletion), authentication needs, error handling, or rate limits, 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.

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

The description is front-loaded with the core purpose, followed by important notes in a structured way. Every sentence adds value: the first states the action, the second specifies prerequisites, and the third provides input formatting guidance, with no wasted words.

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

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

Given the tool's complexity (destructive operation with no annotations or output schema), the description is partially complete. It covers prerequisites and input format but misses key details like parameter explanations, deletion consequences, or expected response format, making it adequate but with clear gaps.

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

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

The input schema has 0% description coverage, with two required parameters (clientId, projectId) undocumented. The description does not add any meaning about these parameters, such as what they represent or how to obtain them, failing to compensate for the schema gap.

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

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

The description clearly states the action ('Delete') and the resource ('a project by ID'), making the purpose specific and unambiguous. It distinguishes this tool from siblings like 'delete-workflow' or 'delete-user' by specifying the project resource type.

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

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

The description provides explicit context for when to use this tool by stating 'Requires n8n Enterprise license with project management features enabled,' which serves as a prerequisite. However, it does not mention when not to use it or name specific alternatives like 'update-project' or 'list-projects' for related actions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool deletes a tag, implying a destructive mutation, but lacks details on permissions required, whether deletion is reversible, error handling (e.g., if ID doesn't exist), or side effects. 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.

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

The description is a single, direct sentence with zero waste. It front-loads the key action and resource efficiently, making it easy to parse. Every word earns its place without redundancy or fluff.

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

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

Given the tool's complexity (a destructive mutation with 2 parameters), lack of annotations, and no output schema, the description is incomplete. It doesn't cover behavioral traits, parameter meanings, or return values, leaving significant gaps for the agent to operate safely and effectively.

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

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

Schema description coverage is 0%, so the description must compensate for undocumented parameters. It mentions 'by ID', which hints at the 'id' parameter, but doesn't explain the 'clientId' parameter at all. The description adds minimal value beyond the schema, failing to clarify parameter purposes or formats.

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

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

The description clearly states the action ('Delete') and resource ('a tag'), specifying it's done 'by ID'. It distinguishes from siblings like 'delete-project' or 'delete-workflow' by focusing on tags. However, it doesn't explicitly differentiate from 'update-tag' in terms of when to delete versus update.

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

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

No guidance is provided on when to use this tool versus alternatives. For example, it doesn't mention prerequisites (e.g., tag must exist), consequences (e.g., what happens to associated workflows), or when to choose 'delete-tag' over 'update-tag' or other deletion tools. The agent must infer usage from context alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action is 'Delete', implying a destructive mutation, but doesn't specify if it's reversible, requires admin permissions, affects related data, or has rate limits. This is inadequate for a destructive 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.

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 purpose without unnecessary elaboration.

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

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

For a destructive tool with 2 required parameters, 0% schema coverage, no annotations, and no output schema, the description is insufficient. It doesn't cover parameter semantics, behavioral risks, or usage context, leaving critical gaps for safe and effective tool invocation.

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

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

Schema description coverage is 0%, so the schema provides no parameter details. The description doesn't mention any parameters or their meanings (e.g., what 'clientId' and 'idOrEmail' represent), failing to compensate for the lack of schema documentation.

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

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

The description clearly states the action ('Delete') and target resource ('a user from your instance'), which is specific and unambiguous. However, it doesn't differentiate from sibling tools like 'delete-credential' or 'delete-project' beyond the resource type, missing explicit sibling distinction.

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

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

No guidance is provided on when to use this tool versus alternatives like 'deactivate-workflow' or 'get-user'. The description lacks context about prerequisites, consequences, or comparisons to other deletion tools in the sibling list.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively communicates critical behavioral traits: the irreversible nature ('This action cannot be undone'), licensing requirements, and input formatting constraints ('Arguments must be provided as compact, single-line JSON without whitespace or newlines'). However, it doesn't mention potential error conditions or response format.

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

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

The description is appropriately sized and front-loaded with the core purpose. Each sentence adds distinct value: the action, licensing requirements, usage guidance, irreversible nature, and input formatting. While efficient, the formatting instruction could be slightly more concise.

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

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

For a destructive tool with no annotations and no output schema, the description provides substantial context: licensing requirements, irreversible nature, usage sequencing with sibling tools, and input formatting. The main gap is the lack of information about what happens after deletion or potential error responses.

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

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

The input schema has 0% description coverage, but the description adds some semantic context by explaining that the 'id' parameter should come from 'list-variables'. However, it doesn't explain what 'clientId' represents or provide any details about parameter formats or constraints beyond the JSON formatting requirement.

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

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

The description clearly states the specific action ('Delete') and resource ('a variable by ID'), distinguishing it from sibling tools like 'create-variable' and 'list-variables'. 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.

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

The description explicitly provides 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 distinguishes from alternatives by referencing the sibling tool 'list-variables' for obtaining IDs.

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

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

With no annotations provided, the description carries full burden. It discloses the critical irreversible nature ('cannot be undone') which is essential for a destructive operation, and specifies JSON formatting requirements. However, it doesn't mention authentication needs, rate limits, error conditions, or what happens to associated 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.

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

The description is extremely concise with just two sentences that each serve distinct purposes: stating the core function and specifying critical formatting requirements. Every word earns its place, and the warning about irreversibility is appropriately front-loaded.

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

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

For a destructive operation with no annotations and no output schema, the description is insufficient. It doesn't explain what constitutes a valid workflow ID, what the 'clientId' parameter is for, what happens upon successful deletion, or what error responses might look like. The irreversible warning is good but doesn't provide complete operational context.

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

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

With 0% schema description coverage for 2 parameters, the description fails to explain what 'clientId' and 'id' represent. While it mentions arguments must be provided as compact JSON, it doesn't clarify parameter meanings, formats, or relationships. The description doesn't 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.

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 ('workflow by ID'), making the purpose immediately understandable. However, it doesn't differentiate this from other deletion tools like 'delete-credential' or 'delete-project' beyond specifying the workflow resource type.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'deactivate-workflow' or 'delete-execution'. It mentions the irreversible nature but doesn't help the agent choose between this and other destructive operations in the sibling tool list.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool generates a security audit but does not explain what the audit does—e.g., whether it scans for vulnerabilities, logs activity, or produces a report. Critical details like permission requirements, rate limits, or whether it's a read-only or mutative operation are missing, leaving 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.

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

The description is a single, efficient sentence that is front-loaded with the main action. It avoids unnecessary words and gets straight to the point. However, it is overly concise given the tool's complexity, as it omits important details that would help an agent use it effectively, slightly reducing its utility.

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

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

Given the tool's complexity (generating a security audit with 3 parameters), lack of annotations, and no output schema, the description is incomplete. It does not cover what the audit entails, how parameters influence it, or what the output looks like. For a tool that likely produces detailed results, this leaves too much undefined, making it inadequate for proper agent usage.

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

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

The input schema has 3 parameters with 0% description coverage, so the schema provides no semantic information. The description does not mention any parameters, failing to compensate for this gap. For example, it does not explain what 'clientId', 'daysAbandonedWorkflow', or 'categories' mean or how they affect the audit, leaving parameters undocumented and unclear in purpose.

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

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

The description states the tool's purpose as 'Generate a security audit for your n8n instance,' which is clear but vague. It specifies the verb 'generate' and resource 'security audit,' but lacks details on what the audit entails or how it differs from other tools. It distinguishes from siblings like 'activate-workflow' or 'create-credential' by focusing on security, but the scope remains broad without specifics.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites, timing, or exclusions, such as whether it requires specific permissions or should be run periodically. With many sibling tools for managing workflows, credentials, and users, there is no indication of when a security audit is appropriate compared to other operations.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It describes what the tool does (shows schema fields) but lacks details on behavioral traits such as whether it's read-only, if it requires authentication, rate limits, error handling, or the format of returned data. The description is functional but misses key operational context needed for an AI agent.

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

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

The description is appropriately sized with two sentences that are front-loaded: the first states the purpose, and the second provides usage context and examples. There's no wasted text, and it efficiently conveys key information, though it could be slightly more structured by explicitly listing parameters.

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

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

Given the tool's moderate complexity (2 required parameters, no output schema, no annotations), the description is somewhat complete but has gaps. It covers the purpose and gives parameter examples, but lacks details on behavior, return values, and full parameter semantics. This makes it adequate but not fully comprehensive for an AI agent to use effectively without additional context.

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

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

Schema description coverage is 0%, so the description must compensate for undocumented parameters. It explains 'credentialTypeName' with examples (e.g., 'cloudflareApi'), adding meaning beyond the schema. However, it doesn't address 'clientId' at all, leaving one of two parameters unexplained. This partial coverage results in a baseline score of 3, as it adds some value but doesn't fully compensate for the schema gap.

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

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

The description clearly states the tool's purpose: 'Show credential data schema for a specific credential type.' It specifies the verb ('show') and resource ('credential data schema'), and distinguishes it from sibling tools like 'create-credential' by focusing on schema retrieval rather than creation. However, it doesn't explicitly differentiate from other 'get-' tools like 'get-execution' or 'get-workflow' beyond the credential focus.

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

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

The description implies usage context by stating 'The credential type name can be found in the n8n UI when creating credentials,' which suggests when to use this tool (to understand credential requirements before creation). However, it doesn't provide explicit guidance on when to use this versus alternatives like 'create-credential' or other 'get-' tools, nor does it specify prerequisites or exclusions.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool retrieves data, implying a read-only operation, but doesn't specify permissions, rate limits, error conditions, or what 'retrieve' entails (e.g., returns execution details). This leaves significant gaps for a tool with 3 parameters and no output schema.

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

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

The description is a single, efficient sentence with no wasted words. It's front-loaded with the core action and resource, making it easy to parse quickly. Every word earns its place by conveying essential information.

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

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

Given the tool's complexity (3 parameters, no output schema, no annotations), the description is inadequate. It doesn't explain what an 'execution' is in this context, what data is returned, or how parameters interact. For a retrieval tool with undocumented inputs and outputs, more detail is needed to guide the agent effectively.

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

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

Schema description coverage is 0%, so the description must compensate for undocumented parameters. It mentions retrieving by ID, which hints at the 'id' parameter, but doesn't explain 'clientId' or 'includeData'. This adds minimal value beyond the schema, failing to clarify parameter meanings or usage.

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

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

The description clearly states the action ('Retrieve') and resource ('a specific execution by ID'), making the purpose understandable. However, it doesn't differentiate from sibling tools like 'list-executions' or 'get-workflow', which also retrieve execution-related data, so it doesn't fully distinguish from alternatives.

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

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

The description provides no guidance on when to use this tool versus alternatives such as 'list-executions' for multiple executions or 'get-workflow' for workflow details. It lacks context on prerequisites or exclusions, leaving the agent to infer usage from the tool name alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states this is a retrieval operation, implying it's likely read-only, but doesn't confirm safety aspects like whether it requires authentication, has rate limits, or what happens if the ID is invalid. The description is minimal and misses key behavioral details.

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

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

The description is a single, efficient sentence with zero wasted words. It's front-loaded with the core action and resource, making it easy to parse quickly.

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

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

Given the tool has 2 required parameters, no annotations, no output schema, and 0% schema description coverage, the description is incomplete. It doesn't explain what the tool returns, error conditions, or provide enough context for safe and effective use, especially for a retrieval operation in a system with multiple tag-related tools.

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

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

The schema description coverage is 0%, so the description must compensate for undocumented parameters. It mentions retrieving by 'ID', which hints at the 'id' parameter, but doesn't explain the 'clientId' parameter at all. This leaves half of the required parameters without semantic context, failing to adequately compensate for the schema gap.

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

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

The description clearly states the verb ('Retrieve') and resource ('a specific tag'), making the purpose unambiguous. However, it doesn't distinguish this tool from its sibling 'list-tags', which would retrieve multiple tags rather than a specific one by ID.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'list-tags' or other tag-related tools (e.g., 'create-tag', 'update-tag', 'delete-tag'). It lacks context about prerequisites, such as needing a valid tag ID, or exclusions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool retrieves user data but omits critical details: whether this is a read-only operation, what permissions are required, how errors are handled (e.g., invalid IDs), or the format of returned data. This leaves significant gaps for a tool that likely interacts with sensitive user information.

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

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

The description is a single, direct sentence with zero wasted words. It front-loads the core purpose ('Get user') and efficiently specifies the key input constraint ('by ID or email address'), making it easy to parse quickly.

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

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

Given the tool's moderate complexity (2 required parameters, no output schema, and no annotations), the description is incomplete. It doesn't explain what data is returned (e.g., user object fields), error conditions, or authentication requirements, which are essential for an agent to use this tool effectively in a real-world context.

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

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

The schema description coverage is 0%, meaning neither parameter (clientId, idOrEmail) is documented in the schema. The description mentions 'ID or email address' which partially explains idOrEmail, but it doesn't clarify clientId at all or provide examples (e.g., format of IDs). This fails to compensate for the schema's lack of documentation.

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

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

The description clearly states the action ('Get user') and the target resource ('by ID or email address'), making the purpose immediately understandable. However, it doesn't differentiate this tool from sibling tools like 'list-users' or 'delete-user', which would require explicit comparison to achieve 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.

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 'list-users' for browsing all users or 'delete-user' for removal. It lacks context about prerequisites (e.g., authentication needs) or typical use cases, leaving the agent to infer usage from the tool name alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It adds important context about argument formatting ('compact, single-line JSON without whitespace or newlines'), which isn't obvious from the schema. However, it doesn't describe what 'detailed information' includes, potential error conditions, or authentication requirements, leaving gaps for a read operation.

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

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

The description is extremely concise and well-structured with only two sentences. The first sentence states the core purpose, the second provides usage guidance, and the third delivers critical formatting requirements. Every sentence earns its place with no wasted words.

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

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

For a read operation with no annotations and no output schema, the description provides adequate basic information about purpose and usage. However, it doesn't explain what 'detailed information' the workflow contains, what format it returns, or address potential edge cases. Given the complexity of workflow systems and lack of structured output documentation, this leaves significant gaps.

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

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

The schema has 0% description coverage, so the description must compensate. It mentions 'ID' as a parameter but doesn't explain what 'clientId' represents or provide any semantic context for either parameter. The description adds minimal value beyond what's implied by the tool name, failing to fully address the schema coverage gap.

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

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

The description clearly states the tool's purpose with a specific verb ('Retrieve') and resource ('workflow by ID'), making it immediately understandable. However, it doesn't explicitly distinguish this tool from similar siblings like 'get-execution' or 'get-user' beyond mentioning 'workflow' specifically.

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

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

The description provides clear usage guidance by specifying when to use it ('Use after list-workflows to get detailed information about a specific workflow'), which helps the agent understand the sequencing. It doesn't explicitly mention when NOT to use it or name alternatives among siblings, but the context is sufficiently clear for proper usage.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states a read operation ('Get'), implying it's non-destructive, but doesn't cover critical aspects like authentication requirements, rate limits, error conditions, or the return format (e.g., list of tag names/IDs). For a tool with no 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.

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

The description is a single, clear sentence with zero wasted words. It front-loads the core purpose ('Get tags associated with a workflow'), making it immediately scannable and efficient. Every word earns its place, adhering to best practices for conciseness.

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

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

Given the tool's moderate complexity (2 parameters, no annotations, no output schema), the description is incomplete. It lacks parameter details, behavioral context (e.g., read-only nature, error handling), and output information (e.g., what 'tags' means—names, IDs, objects?). Without this, the agent has insufficient guidance for reliable tool use.

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

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

Schema description coverage is 0%, so the schema provides no parameter documentation. The description adds no information about the two required parameters ('clientId' and 'workflowId'), such as their purpose, format, or examples (e.g., UUIDs). Without this, the agent cannot understand what values to provide, making the tool difficult to invoke correctly.

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

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

The description clearly states the action ('Get') and resource ('tags associated with a workflow'), making the purpose immediately understandable. It distinguishes this from sibling tools like 'get-tag' (which likely retrieves tag details) or 'update-workflow-tags' (which modifies tags). However, it doesn't specify the verb's scope (e.g., 'retrieve all' or 'fetch'), 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.

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 a valid workflow ID), differentiate from similar tools like 'get-workflow' (which might include tags), or specify use cases (e.g., for filtering workflows by tags). Without such context, the agent must infer usage from the tool name alone.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the tool establishes a connection, implying it's a setup or initialization operation, but lacks details on behavioral traits like error handling, authentication requirements beyond the API key, or whether it's idempotent. The description adds some context but doesn't fully compensate for the absence of annotations.

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

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

The description is appropriately sized and front-loaded: the first sentence states the purpose, the second provides usage guidelines, and the third gives a critical formatting instruction. Every 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.

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

Given the tool's complexity (a connection initialization with 2 parameters), no annotations, no output schema, and low schema coverage, the description is somewhat complete but has gaps. It covers purpose and usage but lacks details on behavioral aspects, parameter meanings, and expected outcomes, making it adequate but not fully comprehensive for an initialization tool.

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

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

The input schema has 2 parameters with 0% description coverage, meaning the schema provides no semantic details. The description adds minimal parameter semantics by mentioning 'n8n URL and API key' and specifying a format requirement ('compact, single-line JSON without whitespace or newlines'), which helps clarify usage. However, it doesn't explain what the URL or API key represent or their expected formats, leaving gaps.

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

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

The description clearly states the tool's purpose: 'Initialize connection to n8n instance.' It specifies the verb ('Initialize') and resource ('connection to n8n instance'), making it unambiguous. However, it doesn't explicitly differentiate from siblings like 'create-credential' or 'create-project', which are distinct operations, so it doesn't reach the highest score.

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

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

The description provides clear context for when to use this tool: 'whenever an n8n URL and API key are shared to establish the connection.' This gives explicit guidance on the triggering condition. However, it doesn't mention when not to use it or name specific alternatives among the siblings, such as other initialization or setup tools, which prevents a perfect score.

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

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

With no annotations provided, the description carries full burden but only states it 'retrieves' executions. It doesn't disclose whether this is a read-only operation, if it requires authentication, rate limits, pagination behavior (despite having a 'limit' parameter), or what the return format looks like. For a tool with 5 parameters and no output schema, this is a significant gap in behavioral context.

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

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

The description is a single, efficient sentence that front-loads the core purpose ('retrieve all executions') and adds qualifying information ('from your instance with optional filtering'). There's no wasted verbiage or redundant information.

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

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

Given 5 parameters with 0% schema coverage, no annotations, no output schema, and multiple sibling tools, the description is incomplete. It adequately states what the tool does at a high level but fails to provide necessary context about parameter usage, behavioral expectations, or differentiation from similar tools, making it insufficient for reliable agent use.

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

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

Schema description coverage is 0%, so the description must compensate but only mentions 'optional filtering' generically. It doesn't explain what 'clientId' represents (required parameter), what 'includeData' controls, the meaning of status enum values, how 'workflowId' filters, or how 'limit' affects results. 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.

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', specifying it retrieves 'all executions from your instance'. It distinguishes from sibling 'get-execution' by indicating it lists multiple executions rather than fetching a single one. However, it doesn't explicitly differentiate from other list tools like 'list-workflows' 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.

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

The description mentions 'optional filtering' which implies when to use parameters, but provides no explicit guidance on when to use this tool versus alternatives like 'get-execution' for single executions or other list tools for different resources. No context about prerequisites, exclusions, or comparison to siblings is given.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It adds context about licensing requirements and input formatting ('Arguments must be provided as compact, single-line JSON'), which are useful behavioral traits. However, it doesn't cover aspects like pagination, rate limits, error handling, or response format, leaving gaps for a list operation.

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

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

The description is appropriately sized with two sentences: one for the core purpose and prerequisites, and another for input formatting. It's front-loaded with the main action, but the formatting note could be more integrated. There's minimal waste, though it could be slightly more streamlined.

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

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

Given the complexity (a list operation with licensing constraints), no annotations, 0% schema coverage, and no output schema, the description is incomplete. It misses details on parameter semantics, return values, error cases, and operational limits, making it inadequate for reliable tool invocation.

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

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

Schema description coverage is 0%, so the description must compensate for the undocumented parameter 'clientId'. The description doesn't explain what 'clientId' is, its purpose, format, or how to obtain it. This leaves the parameter's meaning unclear, failing to add value beyond the bare schema.

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

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

The description clearly states the action ('List all projects') and resource ('from n8n'), providing a specific verb+resource combination. However, it doesn't distinguish this tool from other list tools like 'list-executions' or 'list-workflows' beyond the resource type, missing explicit sibling differentiation.

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

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

The description includes a prerequisite ('Requires n8n Enterprise license with project management features enabled'), which gives some context for when to use it. However, it doesn't provide guidance on when to choose this tool over alternatives like 'get-workflow' or 'list-workflows', nor does it specify exclusions or complementary tools.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states this is a retrieval operation, implying it's likely read-only, but doesn't mention permissions, rate limits, pagination (despite a 'limit' parameter), or what 'all tags' entails (e.g., scope, ordering). 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.

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 scan and understand quickly.

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

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

Given the tool has 2 parameters (one required) with 0% schema coverage, no annotations, and no output schema, the description is incomplete. It doesn't cover parameter meanings, behavioral traits like pagination, or return values, leaving the agent with insufficient context for effective use.

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

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

Schema description coverage is 0%, so the description must compensate but adds no parameter information. It doesn't explain what 'clientId' refers to (e.g., authentication, instance identifier) or how 'limit' affects retrieval (e.g., pagination, max results). This fails to address the undocumented parameters.

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

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

The description clearly states the action ('Retrieve') and resource ('all tags'), making the purpose understandable. However, it doesn't differentiate this tool from its sibling 'get-tag' (which presumably retrieves a single tag), leaving some ambiguity about when to use one versus the other.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'get-tag' or other list operations. It mentions 'from your instance' but doesn't specify context, prerequisites, or exclusions, leaving the agent to infer usage scenarios.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions an access restriction ('Only available for the instance owner'), which is useful context, but fails to describe other key behaviors such as whether this is a read-only operation, what the return format looks like (e.g., list structure, pagination), or any rate limits. 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.

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

The description is extremely concise with two short sentences that directly state the tool's purpose and a key restriction. There is no wasted language, and the information is front-loaded, making it easy to parse quickly.

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

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

Given the tool's complexity (a list operation with access control), lack of annotations, no output schema, and incomplete parameter documentation, the description is insufficient. It omits details on return values, error handling, pagination, and full parameter semantics, making it inadequate for an agent to use the tool effectively without additional context or trial-and-error.

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

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

The input schema has 1 parameter with 0% description coverage, and the tool description does not mention or explain the 'clientId' parameter at all. This leaves the parameter's purpose, format, or how it relates to retrieving users completely undocumented, failing to compensate for the low schema coverage and adding no semantic value beyond the schema.

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

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

The description clearly states the verb ('Retrieve') and resource ('all users from your instance'), making the purpose specific and understandable. However, it does not explicitly differentiate from sibling tools like 'get-user' (singular) or 'create-users', leaving room for ambiguity in distinguishing scope from similar operations.

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

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

The description provides some context by stating 'Only available for the instance owner,' which implies a usage restriction based on permissions. However, it does not offer explicit guidance on when to use this tool versus alternatives like 'get-user' (for a single user) or 'create-users' (for adding users), leaving the agent to infer distinctions from tool names alone.

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

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

No annotations are provided, so the description carries the full burden. It discloses important behavioral traits: the license requirement and the prerequisite to use 'init-n8n' first. It also warns about argument formatting ('Arguments must be provided as compact, single-line JSON without whitespace or newlines'). However, it doesn't cover aspects like rate limits, error handling, or what the output looks like (since there's no output schema), leaving some gaps in behavioral understanding.

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

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

The description is appropriately sized and front-loaded, starting with the core purpose. Each sentence adds value: the purpose, license requirement, usage timing, and argument formatting. There's no wasted text, and it's structured logically, though it could be slightly more polished for a perfect score.

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

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

Given the complexity (a list operation with 1 parameter), no annotations, and no output schema, the description is partially complete. It covers usage prerequisites and behavioral constraints but lacks parameter semantics and output details. For a tool with no structured support, it should do more to explain the parameter and expected results, making it only adequate.

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

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

The input schema has 1 parameter ('clientId') with 0% description coverage, meaning the schema provides no semantic information. The description does not explain what 'clientId' is, its purpose, or how to obtain it. It only mentions argument formatting without adding meaning to the parameter itself. This fails to compensate for the low schema coverage, resulting in a poor score.

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

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

The description clearly states the tool's purpose: 'List all variables from n8n.' It specifies the verb ('List') and resource ('variables from n8n'), making the action clear. However, it doesn't explicitly differentiate from sibling tools like 'create-variable' or 'delete-variable' beyond the obvious list vs. create/delete distinction, which is why it doesn't reach 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.

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

The description provides clear context for when to use the tool: 'Use after init-n8n to see available variables.' This gives a prerequisite and timing guidance. It also mentions a requirement ('Requires n8n Enterprise license with variable management features enabled'), which helps in decision-making. However, it doesn't explicitly state when not to use it or name alternatives, so it falls short of a 5.

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

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

No annotations are provided, so the description carries full burden. It discloses the JSON formatting requirement ('Arguments must be provided as compact, single-line JSON'), which is valuable behavioral context. However, it doesn't mention other important traits like whether this is a read-only operation, pagination behavior, rate limits, or authentication needs - significant gaps for a 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.

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

The description is appropriately sized with two sentences. The first sentence states the purpose and usage context, while the second provides critical formatting instructions. Both sentences earn their place, though the structure could be slightly improved by separating formatting requirements into a distinct section.

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

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

Given 1 parameter with 0% schema coverage and no output schema, the description is incomplete. It provides good usage context and formatting requirements but completely misses parameter semantics. For a tool with no annotations and undocumented parameters, this leaves significant gaps in understanding how to properly invoke the tool.

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

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

The input schema has 1 parameter (clientId) with 0% description coverage. The tool description provides NO information about what 'clientId' represents, its format, or where to obtain it. For a required parameter with no schema documentation, this is a substantial gap that the description fails to address.

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

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

The description clearly states the tool's purpose: 'List all workflows from n8n' - a specific verb ('List') and resource ('workflows from n8n'). It distinguishes from siblings like 'get-workflow' (singular) and 'list-executions' (different resource). However, it doesn't explicitly differentiate from all list-type siblings (e.g., 'list-projects', 'list-tags'), which prevents 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.

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: 'Use after init-n8n to see available workflows' - this gives a prerequisite and timing guidance. It doesn't explicitly state when NOT to use or name alternatives (e.g., 'get-workflow' for single workflow), 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.

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 licensing requirements and input format constraints, which are useful behavioral traits. However, it doesn't mention mutation effects, permissions, error handling, or response format, leaving gaps for a tool that modifies data.

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

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

The description is front-loaded with the core purpose, followed by critical notes in a logical order. Every sentence adds value: the first states what it does, the second covers prerequisites, and the third specifies input format. No wasted words.

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

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

Given no annotations and no output schema, the description provides licensing and format details but lacks information on mutation behavior, error cases, or return values. For a tool that updates data with three required parameters, this leaves significant gaps in understanding how to use it effectively.

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

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

Schema description coverage is 0%, so the description must compensate for undocumented parameters. It only mentions the 'name' parameter indirectly and provides format guidance, but doesn't explain 'clientId' or 'projectId' semantics. This partial compensation is insufficient for three required parameters.

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

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

The description clearly states the verb ('Update') and resource ('a project's name'), making the purpose specific and understandable. However, it doesn't explicitly differentiate from sibling tools like 'update-workflow' or 'update-tag', which prevents 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.

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 gives clear context for when to use this tool. However, it doesn't mention alternatives or when not to use it compared to siblings like 'create-project' or 'delete-project'.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states 'Update a tag's name,' which implies a mutation operation, but doesn't disclose any behavioral traits such as required permissions, whether the update is reversible, potential side effects, or error conditions. This is a significant gap 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.

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 any unnecessary words. It is front-loaded and appropriately sized, making it easy to parse quickly.

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

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

Given the complexity of a mutation tool with 3 undocumented parameters, no annotations, and no output schema, the description is incomplete. It doesn't explain what the parameters mean, what the tool returns, or any behavioral aspects, leaving critical gaps for the agent to operate effectively.

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

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

The schema description coverage is 0%, meaning none of the three parameters (clientId, id, name) are documented in the schema. The description only mentions 'name' as the field to update, adding minimal semantics for one parameter but leaving 'clientId' and 'id' unexplained. This fails to compensate for the low coverage, as the agent lacks context for most inputs.

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

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

The description clearly states the action ('Update') and the resource ('a tag's name'), making the purpose specific and understandable. However, it doesn't explicitly differentiate this tool from sibling tools like 'update-project' or 'update-workflow', which also perform updates on different resources, so it doesn't fully distinguish from siblings.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing tag), exclusions, or compare it to related tools like 'create-tag' or 'delete-tag', leaving the agent to infer usage from context alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the mutation action ('update') and a critical constraint about JSON formatting, but lacks details on permissions, error handling, rate limits, or what happens to unspecified properties. This is insufficient 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.

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

The description is front-loaded with the core purpose, followed by usage guidance and a critical formatting note. Both sentences earn their place, making it efficient, though it could be slightly more structured for clarity.

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

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

Given the complexity (mutation tool with 3 parameters, nested objects, no annotations, and no output schema), the description is incomplete. It misses details on parameter meanings, behavioral traits like side effects, and expected outcomes, leaving significant gaps for the agent.

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

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

Schema description coverage is 0%, so the description must compensate. It only vaguely references 'arguments' without explaining the three parameters (clientId, id, workflow) or their purposes. The JSON formatting note is helpful but doesn't add meaningful semantic context for the parameters themselves.

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

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

The description clearly states the verb ('update') and resource ('existing workflow in n8n'), and specifies what can be modified ('properties, nodes, or connections'). However, it doesn't explicitly differentiate from sibling tools like 'update-project' or 'update-tag', though the workflow focus is implied.

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

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

It provides clear context for when to use ('Use after get-workflow'), which helps guide the agent on prerequisites. However, it doesn't specify when NOT to use this tool or mention alternatives like 'create-workflow' for new workflows, leaving some gaps in comparison.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states 'update' implies a mutation, but doesn't cover permissions, side effects, error handling, or response format. This is inadequate for a tool that modifies data without any structured safety hints.

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

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

The description is a single, efficient sentence with no wasted words. It's front-loaded and appropriately sized for the tool's scope, making it easy to parse quickly.

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

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

Given the tool's complexity (mutation with 3 parameters), lack of annotations, 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 use it correctly.

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

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

Schema description coverage is 0%, so the schema provides no parameter details. The description adds minimal semantics by implying parameters for workflow and tags, but doesn't explain what 'clientId', 'workflowId', or 'tagIds' represent, their formats, or how tag updates work (e.g., replace vs. append). It fails to compensate for the low coverage.

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

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

The description clearly states the verb ('update') and resource ('tags associated with a workflow'), making the purpose understandable. However, it doesn't distinguish this tool from sibling tools like 'update-workflow' or 'update-tag', which could involve similar resources, so it lacks sibling differentiation.

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

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

The description provides no guidance on when to use this tool versus alternatives. For example, it doesn't mention when to choose this over 'update-workflow' or 'get-workflow-tags', nor does it specify prerequisites or exclusions, leaving usage context unclear.

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