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 but doesn't mention permissions needed, whether the change is reversible, side effects (e.g., notifications), or error handling. For a mutation tool, this leaves critical behavioral traits undocumented.

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. Every word earns its place, achieving optimal 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 mutation nature and lack of annotations or output schema, the description is insufficiently complete. It doesn't address behavioral aspects like permissions or side effects, and while the schema covers parameters, overall context for safe and effective use is lacking.

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

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

Schema description coverage is 100%, so the input schema fully documents both parameters ('uuid' and 'completed'). The description adds no additional meaning beyond what the schema provides, such as format details or examples, but meets the baseline since the schema does the heavy lifting.

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 ('Mark a task as completed or uncompleted') and identifies the resource ('task'), making the purpose immediately understandable. However, it doesn't differentiate this tool from sibling tools like 'update_task' which might also handle task status changes, missing an opportunity for explicit 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?

The description provides no guidance on when to use this tool versus alternatives like 'update_task' or 'create_task'. It lacks context about prerequisites (e.g., task must exist), exclusions, or specific scenarios where this tool is preferred, leaving usage ambiguous.

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 creates a note, implying a write operation, but doesn't cover permissions, side effects, error handling, or response format. This is a significant gap for a mutation tool without annotation support.

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 front-loaded with the core purpose and includes essential details without redundancy, making it easy for an agent to parse quickly.

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

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

Given the tool's complexity as a mutation operation with no annotations and no output schema, the description is incomplete. It doesn't address behavioral aspects like what happens on success/failure, whether tags are validated, or how the created note is referenced, leaving gaps for the agent to handle.

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 100%, so the schema already documents both parameters ('content' and 'tags') adequately. The description adds minimal value by mentioning 'markdown content', which aligns with the schema's description for 'content', but doesn't provide additional context beyond what's in the structured 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 action ('Create') and resource ('note'), specifying it's 'new' with 'markdown content'. It distinguishes from siblings like 'update_note' or 'delete_note' by indicating creation, but doesn't explicitly differentiate from other creation tools like 'create_task' or 'create_tag' 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, when not to use it, or compare it to sibling tools like 'create_task' or 'update_note', leaving the agent to infer usage based on 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. 'Create' implies a write operation, but the description doesn't specify permissions needed, whether the tag is unique, what happens on duplicate names, or what the response looks like. It lacks critical behavioral details for a mutation tool.

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

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

The description is a single, efficient sentence with zero waste. It's appropriately sized for a simple tool and front-loaded with the core action, 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?

For a mutation tool with no annotations and no output schema, the description is incomplete. It doesn't address behavioral aspects like error handling, uniqueness constraints, or return values, leaving significant gaps for an agent to understand 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 100%, so the schema already documents the single required 'name' parameter. The description adds no additional meaning beyond what the schema provides, such as naming conventions or constraints. Baseline 3 is appropriate when the schema does the heavy lifting.

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 ('a new tag'), making the purpose immediately understandable. It doesn't explicitly differentiate from sibling tools like 'tag_item' or 'list_tags', but the action is specific enough to be distinguished by context.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'tag_item' or 'list_tags', nor does it mention prerequisites or constraints. It simply states what the tool does without contextual usage information.

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. 'Create a new task' implies a write operation, but it doesn't disclose behavioral traits like whether this requires authentication, what happens on success/failure, if it's idempotent, or any rate limits. 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 extremely concise at three words, front-loaded with the core action. There's zero waste or redundancy, making it easy to parse quickly. Every word earns its place, though this conciseness comes at the cost of detail.

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

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

Given this is a mutation tool with 5 parameters, no annotations, and no output schema, the description is incomplete. It doesn't explain what the tool returns, error conditions, or behavioral context. The 100% schema coverage helps with parameters, but overall context for safe and effective use is lacking.

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

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

Schema description coverage is 100%, so the input schema fully documents all 5 parameters with descriptions. The description adds no additional meaning beyond what's in the schema (e.g., no examples, no constraints beyond schema). Baseline is 3 when schema does the heavy lifting, but the description doesn't compensate or enhance parameter understanding.

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 'Create a new task' clearly states the action (create) and resource (task), but it's quite basic and doesn't differentiate from sibling tools like 'create_note' or 'create_tag' beyond the resource name. It's not tautological but lacks specificity about what kind of task system this is or what distinguishes it from other creation tools.

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

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

No guidance is provided on when to use this tool versus alternatives. With siblings like 'create_note', 'create_tag', and 'update_task', there's no indication of when task creation is appropriate versus note creation or task updates. The description offers no context about prerequisites, typical use cases, 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 mentions the 'move to trash or delete permanently' action but fails to specify permissions required, whether deletion is reversible, or what happens to associated tags/tasks. For a destructive operation, this leaves critical behavioral traits unaddressed.

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 directly states the tool's function without unnecessary elaboration. It's appropriately sized and 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?

For a destructive tool with no annotations and no output schema, the description is incomplete. It doesn't cover behavioral aspects like permissions, reversibility, or effects on related data, nor does it explain return values or error conditions, leaving significant gaps for an AI 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?

The input schema has 100% description coverage, clearly documenting both parameters. The description adds no additional meaning beyond what the schema provides (e.g., it doesn't explain UUID format or clarify the default behavior when 'permanent' is omitted). Baseline 3 is appropriate as the schema does the heavy lifting.

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 ('move to trash or delete permanently') and the resource ('note'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'delete_task' beyond the resource name, 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?

The description provides no guidance on when to use this tool versus alternatives like 'update_note' for archiving or 'delete_task' for other deletions. It lacks context about prerequisites (e.g., note existence) or exclusions, offering minimal usage direction.

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. It mentions the trash/permanent distinction but doesn't address critical aspects like whether deletion is reversible, permission requirements, or system behavior after deletion. For a destructive operation, this is inadequate.

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

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

The description is extremely concise (6 words) with zero wasted language. It's front-loaded with the core action and efficiently communicates the key behavioral choice between trash and permanent deletion.

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

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

For a destructive tool with no annotations and no output schema, the description is insufficient. It doesn't explain what happens after deletion, whether there are confirmation steps, what permissions are needed, or what the response contains. The context signals show this is a mutation tool that needs more behavioral disclosure.

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

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

Schema description coverage is 100%, so the schema already documents both parameters thoroughly. The description mentions the trash/permanent distinction which aligns with the 'permanent' parameter, but doesn't add meaningful semantic context 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 action ('Move to trash or delete permanently') and resource ('task'), making the purpose unambiguous. It doesn't explicitly differentiate from sibling tools like 'delete_note', but the tool name provides that context.

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

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

No guidance is provided about when to use this tool versus alternatives. The description doesn't mention prerequisites, consequences of permanent deletion, or when to choose trash versus permanent deletion, despite having a 'permanent' parameter.

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 'List all tags' implies a read-only operation, it doesn't explicitly state this or mention any behavioral traits like pagination, rate limits, authentication requirements, or whether the operation is idempotent. The mention of 'usage counts' hints at what data is returned, but doesn't fully describe the response format or structure.

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 - a single sentence that communicates the core functionality efficiently. Every word earns its place: 'List' (action), 'all tags' (scope), 'with usage counts' (additional return value). 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?

For a simple list operation with one optional parameter and no output schema, the description provides the basic purpose but lacks important context. It doesn't explain what 'tags' are in this system, how they relate to other entities (notes, tasks, workspaces), or what format the response takes. Given the sibling tools include tag-related operations (create_tag, tag_item, untag_item), more context about the tag ecosystem would be helpful.

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

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

Schema description coverage is 100%, so the schema already fully documents the single parameter 'include_hidden'. The description doesn't add any parameter-specific information beyond what's in the schema. According to scoring rules, when schema coverage is high (>80%), the baseline is 3 even with no param info in the description, which applies here.

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

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

The description clearly states the verb ('List') and resource ('all tags'), making the purpose immediately understandable. It adds 'with usage counts' which provides useful context about what information is returned. However, it doesn't explicitly differentiate this tool from potential sibling operations like 'search_tags' or 'get_tag' (though none exist in the sibling list).

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention whether this is for browsing all tags versus searching for specific ones, nor does it reference any sibling tools that might serve related purposes. There's no context about prerequisites, timing considerations, or when not to use this tool.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'List all workspaces' implies a read-only operation, but it doesn't specify whether it's paginated, returns all data at once, requires authentication, has rate limits, or what the output format is. For a 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 'List all workspaces' is a single, efficient sentence with zero waste. It's front-loaded with the core action and resource, making it easy to parse. Every word earns its place, and there's no redundant or verbose phrasing.

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

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

Given the tool's simplicity (0 parameters, no output schema, no annotations), the description is minimal but incomplete. It states what the tool does but lacks context on behavior (e.g., output format, pagination) and usage guidelines. For a list operation, more details on scope and results would improve completeness, even without complex parameters.

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

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

The tool has 0 parameters, and schema description coverage is 100% (though empty). The description doesn't need to add parameter semantics, as there are none to explain. It appropriately doesn't mention parameters, earning a baseline score of 4 for not introducing unnecessary information.

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

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

The description 'List all workspaces' clearly states the verb ('List') and resource ('workspaces'), making the purpose immediately understandable. It distinguishes from siblings like 'read_workspace' (singular) and 'create_task' (different action), though it doesn't explicitly contrast with them. The description is specific but lacks sibling differentiation details.

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. While it's implied this is for retrieving multiple workspaces (vs. 'read_workspace' for a single one), the description doesn't state this explicitly, mention prerequisites, or specify use cases. It offers no when/when-not instructions or named alternatives.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool retrieves content but lacks details on permissions required, error handling (e.g., for invalid UUIDs), rate limits, or response format. For a read operation with zero annotation coverage, this leaves significant gaps in understanding how the tool behaves beyond its basic function.

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 ('Get full content of a note') without unnecessary words. Every part earns its place by specifying the resource and key parameter, making it easy to parse quickly. No fluff or redundancy detracts from 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 lack of annotations and output schema, the description is incomplete for a tool that retrieves data. It doesn't explain what 'full content' includes (e.g., text, metadata), potential errors, or return structure. For a read operation with no structured output information, the description should provide more context 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?

The description adds minimal value beyond the input schema, which has 100% coverage and fully documents the single 'uuid' parameter. The description mentions 'by UUID', reinforcing the schema's note, but doesn't provide additional context like UUID format examples or where to obtain UUIDs. With high schema coverage, the baseline score of 3 is appropriate as the schema does the heavy lifting.

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 full content') and resource ('a note by UUID'), making the purpose immediately understandable. It distinguishes this from sibling tools like 'search_notes' (which finds notes) or 'update_note' (which modifies notes). However, it doesn't explicitly contrast with 'read_task' or 'read_workspace' for different resource types, keeping it from 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. It doesn't mention when to choose 'read_note' over 'search_notes' (e.g., when you have the exact UUID vs. needing to find notes by content), nor does it specify prerequisites like needing a valid UUID. 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states this is a read operation ('Get'), which implies it's non-destructive, but doesn't address other behavioral aspects like error handling (e.g., what happens with an invalid UUID), authentication requirements, rate limits, or response format. The description is minimal and leaves key behavioral traits unspecified.

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 without any wasted words. It directly communicates the tool's function in a compact form, making it easy to parse 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 lack of annotations and output schema, the description is insufficiently complete. It doesn't explain what 'full details' includes, how errors are handled, or any dependencies. For a read operation with no structured output documentation, the description should provide more context about the return value and operational behavior to be fully helpful.

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 100% description coverage, with the single parameter 'uuid' clearly documented as 'The task UUID'. The description adds no additional parameter semantics beyond what's in the schema, so it meets the baseline score of 3 for adequate coverage when the schema does the heavy lifting.

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 full details') and resource ('task by UUID'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'read_note' or 'read_workspace' beyond specifying the resource type, and 'full details' is somewhat vague about what information is returned.

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 'search_tasks' or 'list_workspaces'. It doesn't mention prerequisites (e.g., needing a valid UUID) or contextual factors that would help an agent choose between this and other read operations in the sibling set.

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. 'Get workspace details' implies a read operation, but it doesn't specify whether this requires authentication, what format the details are returned in, potential error conditions, or any rate limits. For a tool with zero annotation coverage, 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 extremely concise at just three words, front-loading the core purpose without any unnecessary elaboration. Every word earns its place, making it efficient for quick comprehension by an AI agent.

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 lack of annotations and output schema, the description is insufficiently complete. It doesn't explain what 'workspace details' includes, how results are structured, or any behavioral traits like error handling. For a read operation with no structured output documentation, the description should provide more context about what the agent can expect.

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

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

The description doesn't mention parameters at all, but the input schema has 100% description coverage with a clear 'uuid' parameter documented. Since the schema does the heavy lifting, the baseline score of 3 is appropriate—the description adds no parameter semantics beyond what's already in the structured 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 'Get workspace details' clearly states the verb ('Get') and resource ('workspace details'), making the tool's purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'list_workspaces' or 'read_task', which would require specifying what makes this particular read operation unique.

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 'list_workspaces' available, there's no indication whether this is for retrieving specific workspace details by UUID versus listing multiple workspaces, leaving the agent to infer usage context from the parameter schema 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 search functionality but doesn't describe what the tool returns (e.g., list of notes with fields), whether results are paginated, how ranking works, or any rate limits. For a search 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 search tool and front-loaded with the core purpose. Every word earns its place by specifying the resource and searchable fields.

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 (search with 4 parameters) and lack of annotations and output schema, the description is incomplete. It doesn't explain return values, result format, or behavioral traits like sorting or error handling. For a search tool with no structured output documentation, the description should provide more context about what to expect.

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

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

Schema description coverage is 100%, so the schema fully documents all 4 parameters. The description adds minimal value by mentioning 'title, content, or tags', which loosely maps to 'query' and 'tags' parameters, but doesn't provide syntax, format, or interaction details beyond what the schema already specifies. Baseline 3 is appropriate when the schema does the heavy lifting.

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 ('search') and resource ('notes'), and specifies the searchable fields ('title, content, or tags'). It distinguishes from siblings like 'list_tags' or 'read_note' by focusing on search functionality. However, it doesn't explicitly differentiate from 'search_tasks', which is a similar search tool for a different resource.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when to prefer this over 'list_tags' for tag-based queries, or how it differs from 'search_tasks' for task-related searches. There are no prerequisites, exclusions, or context for usage beyond the basic purpose statement.

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 search functionality but doesn't disclose behavioral traits like pagination (implied by limit parameter), default sorting, error conditions, authentication needs, or rate limits. For a search tool with 6 parameters and no annotation coverage, this leaves significant behavioral aspects unexplained.

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

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

Extremely concise single sentence with zero wasted words. It's front-loaded with the core purpose and efficiently lists search criteria. Every element 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 6 parameters with full schema coverage but no annotations or output schema, the description is minimally adequate. It covers the basic purpose but lacks behavioral context, usage guidelines, and output details. For a search tool with moderate complexity, it should provide more guidance on results format or error handling to be fully complete.

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

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

Schema description coverage is 100%, so the schema fully documents all 6 parameters. The description adds minimal value by listing searchable attributes (name, tags, due date, status), which loosely maps to parameters like query, tags, due_before, due_after, but doesn't provide additional syntax, format details, or constraints beyond what the schema already specifies.

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 'search' and resource 'tasks', specifying searchable attributes (name, tags, due date, status). It distinguishes from siblings like list_tags or read_task by focusing on filtered retrieval. However, it doesn't explicitly differentiate from search_notes, which has a similar search pattern for a different resource.

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

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

No guidance on when to use this tool versus alternatives like list_tags or read_task. The description implies usage for filtered task retrieval but doesn't specify prerequisites, exclusions, or compare with other search/filter tools. With siblings like search_notes available, the lack of comparative context is a notable gap.

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 ('Add a tag') which implies a mutation operation, but doesn't disclose whether this requires specific permissions, what happens if the tag already exists on the item, or if there are rate limits. 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, clear sentence with zero wasted words. It's front-loaded with the core action and immediately specifies the target resources. Every word earns its place, making it highly efficient for an agent 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?

For a mutation tool with no annotations and no output schema, the description is incomplete. It doesn't explain what happens on success (e.g., confirmation message, updated item) or failure (e.g., error if tag/item doesn't exist). Given the complexity of associating tags with items and the lack of structured behavioral hints, more context would be helpful.

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

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

Schema description coverage is 100%, so all parameters are documented in the schema. The description adds no additional parameter semantics beyond what the schema provides (e.g., it doesn't explain tag naming conventions, UUID format, or implications of the type default). This meets the baseline for high schema coverage where the description doesn't need to compensate.

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

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

The description clearly states the action ('Add a tag') and the target resources ('to a task or note'), making the purpose immediately understandable. It doesn't explicitly differentiate from sibling tools like 'untag_item' or 'create_tag', but the verb 'Add' versus 'untag' provides some implicit distinction. The description avoids tautology by specifying what gets tagged rather than just restating the tool name.

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

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 'untag_item' (for removal) or 'create_tag' (for tag creation without association). It doesn't mention prerequisites (e.g., needing an existing tag or item) or contextual constraints. The agent must infer usage from the tool name and schema 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 tool performs a removal operation, implying mutation, but doesn't disclose any behavioral traits such as permissions required, whether the operation is reversible, error conditions (e.g., if the tag doesn't exist on the item), or side effects. For a mutation tool with zero annotation coverage, this is a significant gap.

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

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

The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It is front-loaded with the core action ('Remove a tag'), making it easy to parse. Every part of the sentence earns its place by specifying the resource scope ('from a task or note').

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 mutation nature, lack of annotations, and no output schema, the description is incomplete. It doesn't explain what happens after removal (e.g., success confirmation, error messages), behavioral constraints, or how it fits into the broader context of tag management with siblings like 'tag_item' and 'list_tags'. For a 3-parameter mutation tool, more context is needed.

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

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

Schema description coverage is 100%, with all three parameters clearly documented in the schema: 'tag' (required tag name), 'uuid' (required item UUID), and 'type' (item type with default). The description adds no additional parameter semantics beyond what the schema provides, such as format examples or constraints. Baseline 3 is appropriate when the schema does the heavy lifting.

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 ('Remove a tag') and the target resource ('from a task or note'), making the purpose immediately understandable. It distinguishes the tool from its sibling 'tag_item' by specifying the opposite operation. However, it doesn't explicitly differentiate from other mutation tools like 'delete_task' or 'update_task' beyond the tag-specific 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 provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., the item must already have the tag), when not to use it, or how it relates to sibling tools like 'tag_item' (for adding tags) or 'update_task' (which might also modify tags). Usage is implied but not explicitly stated.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the 'append' functionality, which adds some context beyond basic updating. However, it fails to disclose critical behavioral traits such as whether this is a destructive operation (e.g., if 'content' replaces all existing content), what permissions are required, error handling, or response format. For a mutation tool with zero annotation coverage, this is a significant gap.

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

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

The description is extremely concise with just two short sentences, front-loading the core purpose ('Update a note') and adding a useful tip about 'append'. There is zero waste or redundancy, making it easy to parse quickly. Every sentence earns its place by providing essential information efficiently.

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

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

Given the complexity of a mutation tool with 5 parameters, no annotations, and no output schema, the description is incomplete. It lacks details on behavioral aspects like side effects, error conditions, and return values, which are critical for safe and effective use. The high schema coverage helps with parameters, but overall context for tool invocation remains inadequate.

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

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

Schema description coverage is 100%, so the schema already documents all 5 parameters thoroughly. The description adds minimal value by hinting at the 'append' parameter's purpose ('to add to existing content'), but this is largely redundant with the schema's description. It doesn't explain interactions between parameters (e.g., 'content' vs. 'append') or provide additional context, so it meets the baseline for high schema coverage.

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

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

The description clearly states the verb 'Update' and resource 'note', making the purpose immediately understandable. It distinguishes from sibling tools like 'create_note' and 'delete_note' by focusing on modification rather than creation or deletion. However, it doesn't specify what aspects can be updated beyond content, leaving some ambiguity compared to the full parameter set.

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 implied guidance by mentioning 'Use 'append' to add to existing content', suggesting an alternative to replacing content. However, it doesn't explicitly state when to use this tool versus alternatives like 'create_note' for new notes or 'read_note' for viewing, nor does it mention prerequisites like needing the note UUID. The guidance is helpful but incomplete.

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 but offers minimal information. 'Update a task' implies a mutation operation but doesn't specify permission requirements, whether updates are reversible, what happens to unchanged fields, or error conditions. For a mutation tool with zero annotation coverage, this represents a significant transparency gap.

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

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

The description is maximally concise with just three words. While this represents under-specification rather than ideal conciseness, according to the scoring framework, 'every sentence should earn its place' and this single sentence contains no wasted words. The structure is front-loaded with the core 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?

For a mutation tool with 5 parameters, no annotations, and no output schema, the description is incomplete. It doesn't explain what constitutes a successful update, what values are returned, error handling, or behavioral constraints. The agent would need to rely heavily on the schema alone, missing important contextual information about the update 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 100%, so all parameters are documented in the schema itself. The description adds no parameter information beyond what the schema provides. According to scoring rules, when schema coverage is high (>80%), the baseline score is 3 even without parameter details in the description.

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

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

The description 'Update a task' is a tautology that merely restates the tool name without adding specificity. It doesn't distinguish this tool from sibling tools like 'update_note' or clarify what aspects of a task can be updated. While the verb 'update' is clear, the description lacks any detail about scope or resource characteristics.

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

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

No guidance is provided about when to use this tool versus alternatives. The description doesn't mention prerequisites (like needing a task UUID), differentiate from similar tools (like 'complete_task' or 'update_note'), or indicate appropriate contexts for task updates versus other operations. Users 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.