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

With no annotations, the description carries full burden but only states the basic operation. It doesn't disclose behavioral traits like whether this is idempotent, requires specific permissions, affects story state (e.g., triggers workflows), or returns any output. 'Add' implies a mutation, but details are missing.

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

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 action and resources, making it easy to parse quickly 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?

Given no annotations, 0% schema coverage, and no output schema, the description is incomplete. It lacks details on behavior, parameters, return values, error cases, and usage context. For a mutation tool with siblings like 'create_tag_and_add_to_story', more guidance is needed to ensure correct agent 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 but adds minimal meaning. It mentions 'tag_name' and implies 'story_id' via 'to a story', but doesn't explain parameter formats (e.g., string types, IDs), constraints, or examples. This leaves significant gaps for a tool with 2 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 ('Add') and the target resources ('an existing tag to a story'), specifying it's by tag name. It distinguishes from 'create_tag_and_add_to_story' by emphasizing 'existing tag', but doesn't explicitly contrast with other sibling tools like 'update_story' that might also modify tags.

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 is provided. It doesn't mention prerequisites (e.g., tag must exist, story must exist), compare to 'create_tag_and_add_to_story', or specify scenarios where this is appropriate over bulk operations or other updates.

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

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

With no annotations, the description carries full burden but only states the action without behavioral details. It doesn't mention if deletion is permanent/reversible, requires permissions, has rate limits, or affects related data. 'Delete' implies destructive, but specifics like confirmation prompts or error handling are missing, leaving significant 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?

Extremely concise with a single sentence that's front-loaded and wastes no words. Every part ('Delete multiple assets') contributes directly to the purpose, making it efficient despite its simplicity.

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, 0% schema coverage, and no output schema, the description is incomplete. It lacks critical context like deletion consequences, error cases, or return values. Sibling tools suggest a rich asset management system, but this description doesn't help the agent navigate complexity or risks adequately.

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

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

Schema description coverage is 0%, and the description adds no parameter information. It doesn't explain what 'asset_ids' are, their format, valid ranges, or constraints. For a single required parameter with no schema documentation, the description fails to compensate, leaving the agent guessing about input requirements.

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 'Delete multiple assets' clearly states the action (delete) and resource (assets), but it's vague about scope and doesn't differentiate from sibling 'delete_asset' which presumably deletes single assets. It specifies 'multiple' which is helpful but lacks detail about what constitutes an asset or deletion behavior.

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 'delete_asset' or 'bulk_restore_assets'. The description implies bulk operations but doesn't specify thresholds (e.g., use for >1 asset) or prerequisites. Sibling tools include both single and bulk operations, but no comparison is provided.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action ('Move') but lacks details on permissions, whether the move is reversible, effects on asset metadata, or error handling for invalid inputs, which are critical for a mutation tool.

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

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

The description is a single, efficient sentence that directly states the tool's function without unnecessary words. It's front-loaded and wastes no space, 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, 0% schema coverage, and no output schema, the description is insufficient. It lacks details on behavior, parameters, outcomes, or error cases, 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 'assets' and 'folder' but doesn't explain what 'asset_ids' or 'asset_folder_id' represent (e.g., format, constraints), leaving semantics unclear beyond the schema's basic types.

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') and resources ('multiple assets to a folder'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'bulk_delete_assets' or 'bulk_restore_assets' beyond the verb, missing specific distinctions in scope or effect.

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 specify if this is for batch operations versus single moves, or mention prerequisites like folder existence, 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 full burden for behavioral disclosure. It states the tool restores deleted assets, implying a mutation operation, but provides no information about permissions required, whether restoration is reversible, rate limits, side effects, or what happens if some assets can't be restored. For a bulk mutation 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 a single, efficient sentence with zero wasted words. It's appropriately sized for a tool with one parameter and gets straight to the point without unnecessary elaboration or repetition.

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

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

For a bulk mutation tool with no annotations, 0% schema description coverage, and no output schema, the description is insufficient. It doesn't address critical context like error handling, permissions, constraints, or what the tool returns. The agent lacks necessary information to use this tool safely and effectively in production 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?

Schema description coverage is 0%, so the description must compensate for undocumented parameters. The description mentions 'multiple deleted assets' which implies the 'asset_ids' parameter, but provides no details about format, constraints, or what constitutes valid asset IDs. It doesn't explain whether all assets must be from the same space/folder or if there are limits on how many can be restored at once.

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 ('Restore') and target ('multiple deleted assets'), providing a specific verb+resource combination. It distinguishes from siblings like 'restore_story_version' by focusing on assets rather than stories, but doesn't explicitly differentiate from other bulk operations like 'bulk_delete_assets' or 'bulk_move_assets' beyond the restore action.

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 (e.g., assets must be deleted first), constraints (e.g., maximum number of assets), or when to choose this over individual restore operations. It simply states what the tool does without context for 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 states 'Create' implying a write operation, but lacks details on permissions, side effects (e.g., if parent_id affects hierarchy), error conditions, or response format. This leaves significant behavioral 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 extremely concise with two sentences that directly state the action and parameters. It is front-loaded with the purpose and wastes no words, 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, 0% schema coverage, and no output schema, the description is incomplete. It lacks behavioral context (e.g., what happens on success/failure), parameter details, and doesn't leverage sibling tools for differentiation, 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 mentions 'name' and 'optional parent_id', adding basic semantics, but doesn't explain what 'parent_id' refers to (e.g., another folder ID), constraints on 'name' (e.g., uniqueness, length), or format expectations. This is insufficient for the two 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 'Create' and the resource 'asset folder', making the purpose explicit. It distinguishes this tool from siblings like 'create_component_folder' by specifying the resource type, though it doesn't explicitly contrast with them.

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 'create_component_folder' or 'update_asset_folder'. The description only lists parameters without context about prerequisites, dependencies, or typical use 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?

With no annotations provided, the description carries full burden but offers minimal behavioral insight. It states 'Create' which implies a write/mutation operation, but doesn't disclose permissions needed, whether it's idempotent, what happens on conflicts, or what the response contains. For a mutation tool with zero annotation coverage, 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 brief and front-loaded with the core purpose. Both sentences are relevant: the first states the action, the second provides parameter guidance. There's no unnecessary verbiage, though it could be more informative without sacrificing 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?

For a mutation tool with no annotations, 0% schema description coverage, no output schema, and a complex nested parameter, the description is inadequate. It doesn't explain the component object structure, creation behavior, error conditions, or return values. The agent lacks sufficient 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?

Schema description coverage is 0%, and the description only vaguely mentions 'component object with name, display_name, schema, etc.' without explaining what these fields mean, their formats, or which are required. With 1 parameter that's a nested object with unspecified properties, the description adds minimal value beyond the schema's structure.

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

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

The description clearly states the action ('Create') and resource ('component'), making the purpose immediately understandable. It distinguishes from sibling tools like 'update_component' or 'delete_component' by specifying creation. However, it doesn't explicitly differentiate from similar creation tools like 'create_story' or 'create_tag' 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 provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, when creation is appropriate, or what distinguishes it from other creation tools like 'create_story' or 'create_tag'. 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?

No annotations are provided, so the description carries full burden. It mentions creation but doesn't disclose behavioral traits like permissions required, whether it's idempotent, what happens on duplicate names, or error conditions. The phrase 'Pass name' hints at a required parameter but doesn't explain 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 very brief (two short sentences) and front-loaded with the core purpose. However, the second sentence 'Pass name.' is somewhat awkward and could be integrated more smoothly, slightly reducing efficiency.

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

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

Given no annotations, no output schema, and low schema coverage, the description is inadequate. It lacks details on behavior, error handling, return values, and usage context, making it incomplete for a mutation tool with a required parameter.

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 mentions the 'name' parameter but provides no semantic context—no format, length limits, uniqueness rules, or examples. This 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 action ('Create') and resource ('component folder'), which is specific and unambiguous. It distinguishes from siblings like 'create_asset_folder' by specifying the folder type, though it doesn't explicitly differentiate beyond that.

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 'create_asset_folder' or 'update_component_folder'. The description only states what it does without context about prerequisites, constraints, or appropriate 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 for behavioral disclosure. It states this is a creation operation but doesn't mention permissions required, whether the operation is idempotent, what happens on duplicate slugs, or what the response contains. 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 extremely concise at just 8 words, front-loading the essential information. Every word earns its place by specifying the action, resource, and parameters. There's zero redundancy or 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 creation tool with 3 parameters, 0% schema description coverage, no annotations, and no output schema, the description is inadequate. It doesn't explain what a datasource is in this system, what happens after creation, error conditions, or relationship to other tools like 'fetch_datasources'. The agent lacks sufficient 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?

Schema description coverage is 0%, so the schema provides no parameter documentation. The description mentions 'name, slug, and optional dimensions' which maps directly to the 3 parameters, providing basic semantic meaning. However, it doesn't explain what a 'slug' is, what format it should have, what dimensions represent, or any constraints on these values.

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 the resource 'datasource', making the purpose immediately understandable. It distinguishes from siblings like 'create_datasource_entry' by focusing on the datasource itself rather than its entries. However, it doesn't specify what a datasource is in this context, leaving some ambiguity about the resource being created.

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 how it differs from similar tools like 'update_datasource' or 'create_datasource_entry'. 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 full burden. It states 'Create' implying a write operation, but doesn't disclose behavioral traits like permissions required, whether it's idempotent, error handling, or what happens on success/failure. For a mutation tool with zero annotation coverage, this is inadequate.

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

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 action and lists key parameters, 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 a mutation tool with 4 parameters, 0% schema coverage, no annotations, and no output schema, the description is incomplete. It lacks details on parameters, behavioral context, usage scenarios, and expected outcomes, which are critical for 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 description must compensate. It mentions 'name, value, and optional dimension', covering 3 of 4 parameters but omitting the required 'datasource_id'. It doesn't explain what these parameters mean (e.g., what 'dimension' represents) or provide examples, leaving significant 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 action ('Create') and resource ('a datasource entry'), specifying what it does. It distinguishes from siblings like 'create_datasource' (which creates the datasource itself) and 'update_datasource_entry' (which modifies existing entries). However, it doesn't explicitly mention the required 'datasource_id' parameter, which is a minor gap in specificity.

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 datasource), exclusions, or comparisons to siblings like 'create_datasource' or 'update_datasource_entry'. This leaves the agent without context for tool selection.

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

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

No annotations are provided, so the description carries the full burden. It states 'Create a release' which implies a write operation, but doesn't disclose behavioral traits like required permissions, whether it's idempotent, what happens on failure, or the response format. 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 extremely concise and front-loaded, using only one sentence with no wasted words. Every part (verb, resource, parameters) earns its place, 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's complexity (a creation operation with 3 parameters), lack of annotations, and no output schema, the description is incomplete. It doesn't cover behavioral aspects, error handling, or return values, leaving gaps that could hinder correct tool invocation by 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 description lists parameters: 'name and optional story_ids, scheduled_at', adding meaning beyond the input schema which has 0% description coverage. It clarifies that 'name' is required and others are optional, but doesn't explain what 'story_ids' or 'scheduled_at' represent (e.g., format, constraints). With low schema coverage, it partially compensates but not fully.

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 'release', specifying what the tool does. It distinguishes from siblings like 'update_release' or 'delete_release' by focusing on creation. However, it doesn't explicitly differentiate from all siblings (e.g., 'create_story'), though the resource specificity helps.

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

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

No guidance is provided on when to use this tool versus alternatives. It doesn't mention prerequisites, when not to use it, or how it relates to siblings like 'update_release' or 'fetch_releases'. The description only states what it does, not the context for its application.

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 states this is a creation operation but doesn't mention permissions required, whether it's idempotent, what happens on duplicate slugs, or what the response contains. 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 appropriately concise with two sentences that efficiently convey the core functionality and key parameter details. It's front-loaded with the main purpose and avoids unnecessary elaboration, though it could be slightly more structured.

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

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

For a mutation tool with no annotations, no output schema, and incomplete parameter documentation (50% schema coverage), the description is inadequate. It doesn't address critical context like error conditions, response format, or how this tool relates to siblings like 'publish_story', leaving the agent with 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?

Schema description coverage is 50% (only the 'story' parameter has a description). The description adds value by listing example fields (name, slug, content, parent_id) and clarifying that 'publish=1' is optional, which helps interpret the schema. However, it doesn't fully compensate for the coverage gap, especially for the 'story' object's structure and 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 a new story') and resource ('story'), making the purpose immediately understandable. However, it doesn't differentiate this from sibling tools like 'duplicate_story' or 'create_story_and_add_to_story' (which doesn't exist but similar patterns exist), so it doesn't achieve full 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_story' or 'duplicate_story'. It mentions an optional 'publish=1' parameter but doesn't explain when to use it versus the separate 'publish_story' sibling tool, leaving the agent without clear usage context.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It states the tool creates a tag, implying a write/mutation operation, but doesn't disclose any behavioral traits like permission requirements, whether duplicate tag names are allowed, what happens on success/failure, or if there are rate limits. The description is minimal and lacks crucial operational 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 with just two sentences that are front-loaded and waste no words. Every part earns its place: the first sentence states the core purpose, the second adds important optional functionality. This is an excellent example of efficient communication.

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 (creates resources) with no annotations, no output schema, and 0% schema description coverage, the description is incomplete. It doesn't explain what happens after creation, what the response contains, error conditions, or any behavioral constraints. For a tool that modifies system state, this level of documentation is 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?

With 0% schema description coverage for both parameters, the description must compensate but only partially does so. It mentions 'story_id' as optional for linking to a story, adding some semantic context, but provides no information about the 'name' parameter (required, type, constraints) or what format story_id should be. The description doesn't adequately cover the parameter semantics 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 ('Create') and resource ('a tag'), making it immediately understandable. It distinguishes from sibling 'create_tag_and_add_to_story' by not automatically linking to a story, but doesn't explicitly differentiate from other creation tools like 'create_story' or 'create_component'.

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 mentioning 'Optionally link to a story via story_id,' suggesting this is for creating standalone tags that can be associated with stories. However, it doesn't provide explicit guidance on when to use this versus alternatives like 'create_tag_and_add_to_story' or when tag creation is appropriate versus using existing tags.

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 the conditional behavior ('If the tag exists, it is linked'), which is useful, but lacks details on permissions, error handling, or what 'linked' entails (e.g., if it updates existing tag properties). For a mutation tool with no annotations, this is insufficient.

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

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

The description is a single, efficient sentence that front-loads the core action ('Create a tag and add it to a story') and adds conditional behavior without waste. Every word earns its place.

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

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

Given no annotations, 0% schema coverage, and no output schema, the description is incomplete. It lacks details on parameters, return values, error cases, and behavioral nuances (e.g., idempotency or side effects), which are critical for a mutation tool with siblings like 'create_tag'.

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 'name' or 'story_id' represent (e.g., format, constraints, or examples), leaving parameters largely undocumented. The description adds no semantic value beyond what the bare schema provides.

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

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 specific verbs ('create' and 'add') and resources ('tag' and 'story'), and distinguishes it from sibling tools like 'create_tag' (which only creates) and 'add_existing_tag_to_story' (which requires an existing tag).

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

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

The description implies when to use this tool by stating 'If the tag exists, it is linked,' suggesting it handles both creation and linking scenarios. However, it does not explicitly compare it to alternatives like using 'create_tag' followed by 'add_existing_tag_to_story' or provide when-not-to-use guidance.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states 'create' implies a write operation but lacks details on permissions, side effects, error handling, or response format. 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 brief and front-loaded with the main action, using only two sentences. However, the second sentence is somewhat vague ('etc.') and could be more precise. Overall, it avoids unnecessary verbosity but lacks structural clarity 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 of a creation tool with 4 parameters, no annotations, and no output schema, the description is incomplete. It fails to explain behavioral aspects, parameter meanings, or return values, leaving critical gaps for an AI agent to invoke 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 description must compensate. It lists parameters (name, description, assigned_to_user_id, story_id) but provides no semantic context—no explanations of what these fields mean, their constraints, or examples. This adds minimal value beyond the schema's property names.

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

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

The description clearly states the verb 'create' and the resource 'task', making the purpose evident. It distinguishes from siblings like 'update_task' or 'delete_task' by specifying creation. However, it doesn't explicitly differentiate from other creation tools (e.g., 'create_story'), leaving room for slight 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 story_id for context), exclusions, or comparisons with similar tools like 'create_story' or 'update_task'. Usage is implied only through the action '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 of behavioral disclosure. It states the action ('Create') but lacks details on permissions required, whether the operation is idempotent, rate limits, error conditions, or what the response includes. 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, efficient sentence that front-loads the core action and lists parameters without unnecessary words. Every part earns its place, 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 5-parameter mutation tool with no annotations and no output schema, the description is incomplete. It covers basic parameters but misses critical behavioral details (e.g., authentication needs, response format, error handling), making it insufficient 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?

The description lists parameters (name, url, events, description, secret) and indicates which are optional, adding value beyond the schema's 0% description coverage. However, it doesn't explain parameter meanings (e.g., what 'events' entails, format for 'secret'), leaving gaps in understanding despite compensating somewhat for the schema's lack of descriptions.

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

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

The description clearly states the verb ('Create') and resource ('a webhook'), making the purpose immediately understandable. However, it doesn't distinguish this tool from sibling tools like 'update_webhook' or 'delete_webhook' beyond the obvious action difference, missing explicit differentiation about when to create 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?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing admin permissions), compare to sibling tools like 'update_webhook' or 'delete_webhook', or specify scenarios for webhook creation, leaving the agent with minimal context for decision-making.

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 for behavioral disclosure. 'Create' implies a write/mutation operation, but the description doesn't mention permission requirements, whether this operation is idempotent, what happens on failure, or what the response contains. For a creation 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 extremely concise - just two sentences that directly state the action and parameters. Every word earns its place with zero redundancy or unnecessary elaboration. It's front-loaded with the core purpose immediately.

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 creation tool with no annotations, no output schema, and 0% schema description coverage, the description is insufficiently complete. It doesn't address what a workflow is in this system, what happens after creation, error conditions, or relationship to other entities. The context signals indicate this is a non-trivial tool (2 parameters including an array of objects), but the description provides minimal 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, the description adds some value by mentioning 'name and optional stages' which maps to the two parameters. However, it doesn't explain what constitutes a valid name format, what 'stages' represent, or their expected structure beyond 'array of objects'. The description partially compensates for the schema gap but leaves important semantic details unspecified.

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 'workflow', making the purpose specific and understandable. However, it doesn't differentiate this tool from sibling tools like 'create_asset_folder' or 'create_component' - all are creation tools for different resources, but the description doesn't explain what makes a workflow distinct from these other entities.

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 many sibling creation tools (create_asset_folder, create_component, create_datasource, etc.), there's no indication of what context warrants creating a workflow versus other entities. No prerequisites, exclusions, or alternative suggestions are mentioned.

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

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

With no annotations provided, the description carries full burden but only states the action without behavioral details. It doesn't disclose if deletion is permanent, requires specific permissions, has side effects (e.g., cascading deletions), or returns confirmation data. For a destructive operation, 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 with no wasted words. It's front-loaded with the core action ('Delete an asset'), making it easy to parse quickly for 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?

For a destructive tool with no annotations, 0% schema coverage, and no output schema, the description is inadequate. It lacks critical context like permanence, permissions, error cases, or what happens post-deletion. Given the complexity and risk of deletion operations, more completeness 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 0%, so the description must compensate. It mentions 'by ID', which clarifies the 'asset_id' parameter's purpose, but doesn't specify ID format, validation rules, or error handling. This adds minimal semantic value beyond the schema's structural definition.

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

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

The description clearly states the verb ('Delete') and resource ('an asset'), specifying it's done 'by ID'. It distinguishes from siblings like 'bulk_delete_assets' by implying single-asset deletion, but doesn't explicitly contrast with other delete operations like 'delete_asset_folder'.

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 'bulk_delete_assets' or other delete operations (e.g., 'delete_story'). The description lacks context about prerequisites, permissions needed, or recovery options, leaving the agent to infer usage from the name alone.

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

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

No annotations are provided, so the description carries full burden. While 'Delete' implies a destructive operation, it doesn't disclose critical behavioral traits like whether deletion is permanent or reversible, what happens to contained assets, required permissions, or error conditions. This is inadequate 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, direct sentence with zero wasted words. It's perfectly front-loaded, immediately conveying the core action 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 operation with no annotations and no output schema, the description is incomplete. It doesn't cover behavioral implications, success/error responses, or usage context relative to sibling tools. The conciseness comes at the expense of necessary contextual information.

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 mentions the parameter ('ID') but doesn't explain what constitutes a valid asset folder ID, format requirements, or where to obtain it. With only 1 parameter, this is minimally adequate but leaves important semantic 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 action ('Delete') and resource ('asset folder by ID'), making the purpose immediately understandable. However, it doesn't differentiate this tool from other deletion tools like 'delete_asset' or 'delete_component', which would require a 5.

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

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 'bulk_delete_assets' and 'delete_asset', there's no indication of whether this is for single folders, what prerequisites exist, or when other deletion methods are preferable.

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. 'Delete' clearly indicates a destructive operation, but the description doesn't specify whether deletion is permanent or reversible, what permissions are required, whether there are dependencies or cascading effects, or what happens to associated data. For a destructive tool with zero annotation coverage, this leaves critical behavioral aspects 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 that gets straight to the point with zero wasted words. It's appropriately sized for a simple deletion operation and front-loads the essential information. Every word earns its place in this minimal description.

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, no output schema, and minimal parameter documentation, the description is incomplete. It doesn't address critical aspects like whether the deletion is permanent, what permissions are needed, what happens to dependent resources, or what the tool returns. Given the complexity of a delete operation and the lack of structured documentation, the description should provide more behavioral 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 input schema has 1 parameter with 0% description coverage, so the schema provides no semantic information about 'component_id'. The description adds minimal value by mentioning 'by ID', which confirms the parameter identifies the component, but doesn't explain what format the ID should be, where to find it, or provide any examples. This doesn't adequately 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 ('Delete') and target resource ('a component by ID'), making the purpose immediately understandable. It distinguishes from siblings like 'delete_component_folder' by specifying component deletion rather than folder deletion. However, it doesn't explicitly differentiate from other deletion tools like 'delete_story' or 'delete_asset' 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 provides no guidance on when to use this tool versus alternatives. There are multiple deletion tools in the sibling list (e.g., delete_asset, delete_story, delete_component_folder), but the description doesn't help an agent understand when component deletion is appropriate versus other deletion operations. No prerequisites, constraints, or alternatives are mentioned.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool performs a deletion but doesn't specify whether this is permanent, requires specific permissions, affects nested items, or has rate limits. The description is minimal and lacks critical behavioral context needed for safe operation of a destructive action.

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 directly states the tool's function. It's front-loaded with the core action and resource, with no unnecessary words. Every part of the sentence earns its place by specifying the operation and required parameter.

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 destructive operation with no annotations, 0% schema description coverage, and no output schema, the description is incomplete. It doesn't address safety considerations, error conditions, return values, or system impact. For a deletion tool, this level of minimalism creates significant risk 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 mentions the parameter 'component_folder_id' and specifies it's used 'by ID', which adds meaning beyond the schema's type declaration. However, it doesn't explain what a component folder ID is, its format, or where to find it, leaving significant gaps in 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 clearly states the action ('Delete') and target resource ('a component folder by ID'), making the purpose immediately understandable. It distinguishes from siblings like 'delete_component' or 'delete_asset_folder' by specifying the resource type. However, it doesn't explicitly mention what 'component folder' means in this context or how it differs from other folder types.

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. The description doesn't mention prerequisites (e.g., whether the folder must be empty), consequences (e.g., if it's permanent or reversible), or when to choose this over other deletion tools like 'bulk_delete_assets' or 'delete_asset_folder'. 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 the action ('Delete') but lacks critical details: whether this is irreversible, what permissions are required, if it affects related data (e.g., entries), or what happens on success/failure. This is a significant gap for a destructive operation.

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

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

The description is a single, efficient sentence that front-loads the core action and resource. There is no wasted verbiage, making it easy to parse quickly while conveying the essential purpose.

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

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

For a destructive tool with no annotations and no output schema, the description is incomplete. It fails to address critical aspects like side effects, error conditions, or return values, leaving the agent with insufficient information to use the tool 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?

The description adds minimal meaning beyond the input schema, which has 0% coverage. It specifies that the parameter is an ID for a datasource, but doesn't explain the ID format, source, or constraints. With one parameter and low schema coverage, the description provides basic context but doesn't fully 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 the resource ('a datasource by ID'), making the purpose immediately understandable. It distinguishes itself from siblings like 'delete_datasource_entry' by specifying the resource type, though it doesn't explicitly contrast with other deletion tools (e.g., 'delete_asset').

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 the description implies usage for deleting datasources, it doesn't mention prerequisites (e.g., datasource must exist), exclusions (e.g., cannot delete if in use), or direct comparisons to similar tools like 'bulk_delete_assets'.

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. 'Delete' implies a destructive, irreversible mutation, but the description doesn't specify permissions required, whether deletions are permanent or recoverable, error conditions, or what happens upon success. For a destructive 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 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 for such a simple statement.

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, no output schema, and parameters with 0% schema coverage, the description is incomplete. It doesn't address critical context like what 'delete' entails operationally, potential side effects, or how to verify success. For a mutation tool with no structured support, more descriptive detail 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?

The input schema has 2 parameters with 0% description coverage, meaning neither parameter is documented in the schema. The description adds no information about what 'datasource_id' and 'entry_id' represent, their formats, or how to obtain them. This fails to compensate for the schema's lack of documentation, leaving parameters semantically unclear.

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

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

The description 'Delete a datasource entry' clearly states the verb (delete) and resource (datasource entry), making the purpose understandable. However, it doesn't distinguish this tool from other delete operations in the sibling list (like delete_asset, delete_story, etc.), which all follow the same pattern. The purpose is clear but 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. There are related tools like 'bulk_delete_assets' and 'delete_datasource' in the sibling list, but the description doesn't mention any context, prerequisites, or exclusions. Without such guidance, 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 full burden for behavioral disclosure but offers minimal information. It states the destructive action ('Delete') but doesn't cover critical aspects like whether deletion is permanent/reversible, permission requirements, confirmation prompts, side effects, or error conditions. This is inadequate for a destructive 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 (5 words) and front-loaded with the essential action and target. There's zero wasted language, making it easy to parse quickly despite its informational shortcomings.

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, 0% schema coverage, and no output schema, the description is severely incomplete. It lacks behavioral context, parameter details, usage guidance, and output expectations. The conciseness comes at the cost of necessary information for safe 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 but doesn't. It mentions 'by ID' which hints at the release_id parameter, but provides no details about ID format, where to obtain it, or validation rules. The single parameter remains largely undocumented.

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 release by ID'), making the purpose immediately understandable. It doesn't explicitly differentiate from sibling delete tools like delete_asset or delete_story, but the resource specificity (release) provides adequate 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. It doesn't mention prerequisites (like needing a valid release ID), consequences of deletion, or relationships with sibling tools like fetch_releases (to get IDs) or create_release (to create new ones).

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

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

With no annotations, the description carries full burden. It states 'permanently' which hints at irreversibility, but doesn't cover permissions needed, confirmation steps, error conditions, or what happens to associated data. For a destructive tool, this is insufficient behavioral disclosure.

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. It's front-loaded with the core action and qualification, making it highly 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?

For a destructive tool with no annotations, 0% schema coverage, and no output schema, the description is inadequate. It lacks details on permissions, side effects, error handling, and result format, leaving significant gaps for safe 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. It implies 'story_id' is needed but doesn't explain its format, source, or validation. The description adds minimal value beyond the schema's parameter name, resulting in a baseline 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 verb ('Delete') and resource ('a story'), specifying it's a permanent deletion. It distinguishes from siblings like 'restore_story_version' or 'bulk_delete_assets' by focusing on single story deletion, though it doesn't explicitly contrast them.

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 'bulk_delete_assets' or 'delete_asset', nor prerequisites such as needing story permissions. The description implies deletion but lacks context for decision-making.

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 states the tool deletes a tag, implying a destructive mutation, but doesn't disclose critical behavioral traits like whether deletion is permanent, requires specific permissions, has side effects (e.g., removing tag from stories), or returns confirmation. This is a significant gap for a destructive operation.

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

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

The description is a single, direct sentence with zero waste. It's front-loaded and efficiently conveys the core action without unnecessary elaboration, 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 destructive nature, lack of annotations, no output schema, and minimal parameter details, the description is incomplete. It fails to address behavioral aspects like permanence, permissions, or response format, leaving gaps for safe and effective use by an AI agent.

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

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

The description adds minimal meaning beyond the input schema: it clarifies that 'tag_id' identifies the tag to delete. With 0% schema description coverage and 1 parameter, this provides basic context but doesn't detail format (e.g., string format) or constraints. Baseline is 3 as the schema covers the parameter structure adequately.

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 by ID'), making the purpose unambiguous. However, it doesn't differentiate from sibling tools like 'delete_asset' or 'delete_story' beyond specifying the resource type, which is somewhat implied but not explicit.

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 'update_tag' and 'create_tag', there's no indication of prerequisites (e.g., tag must exist) or when deletion is appropriate versus updating. The description lacks context for decision-making.

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 states 'Delete' which implies a destructive, irreversible mutation, but doesn't disclose behavioral traits like permissions required, whether deletion is permanent or soft, confirmation prompts, error handling, or side effects. The description adds minimal value beyond the obvious implication of deletion.

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's front-loaded with the core action and resource, making it easy to parse quickly. Every word earns its place by conveying essential information without redundancy.

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

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

Given the tool's complexity (destructive mutation), lack of annotations, no output schema, and low schema coverage, the description is incomplete. It doesn't cover behavioral aspects like safety, permissions, or response format, which are critical for a deletion tool. The description is minimal and fails to provide sufficient context 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%, with 1 parameter (task_id). The description mentions 'by ID', which adds semantic context that task_id is an identifier, but doesn't specify format (e.g., numeric, UUID), source, or validation rules. It partially compensates for the lack of schema descriptions but leaves gaps in 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 clearly states the action ('Delete') and target resource ('a task by ID'), making the purpose immediately understandable. It distinguishes itself from other deletion tools (like delete_story, delete_asset) by specifying the resource type. However, it doesn't explicitly differentiate from sibling 'bulk_delete_assets' in terms of scope or method.

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., task must exist), when not to use it (e.g., for bulk operations), or direct alternatives like 'bulk_delete_assets' or 'delete_task' vs 'update_task' for archiving. Usage is implied by the name 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 full burden. It mentions deletion but doesn't disclose critical behavioral traits: whether this is permanent or reversible, if it requires specific permissions, what happens on success/failure, or any rate limits. For a destructive operation 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, clear sentence with zero wasted words. It's front-loaded with the core action and resource, making it highly efficient and 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 destructive nature, no annotations, no output schema, and low schema coverage, the description is incomplete. It doesn't cover behavioral aspects like side effects, error handling, or return values, which are crucial for safe invocation. This leaves significant gaps for an AI 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?

Schema description coverage is 0%, but the description adds minimal semantics by specifying that 'webhook_id' is required for deletion. However, it doesn't explain what format the ID should be (e.g., string format, where to find it), leaving the schema to define the type alone. With one parameter, the baseline is 4, but the lack of format details reduces it to 3.

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

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

The description clearly states the action ('Delete') and resource ('a webhook by ID'), making the purpose immediately understandable. It distinguishes from sibling tools like 'create_webhook' and 'update_webhook' by specifying deletion. However, it doesn't explicitly mention what 'webhook' refers to in this context (e.g., from a specific system), 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 no guidance on when to use this tool versus alternatives like 'bulk_delete_assets' or 'delete_workflow', nor does it mention prerequisites (e.g., needing an existing webhook ID). It simply states what the tool does without context for selection among siblings.

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

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 'Delete' which implies a destructive mutation, but fails to describe critical traits: whether deletion is permanent or reversible, required permissions, error conditions (e.g., if the workflow is in use), or what happens to associated data. This is a significant gap for a destructive operation 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 with zero wasted words. It's front-loaded with the core action ('Delete') and resource ('workflow'), making it immediately understandable. Every word earns its place, achieving optimal conciseness for such a straightforward tool.

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

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

Given the tool's destructive nature, lack of annotations, no output schema, and low schema coverage, the description is incomplete. It doesn't address behavioral risks, return values, error handling, or usage context. For a mutation tool with significant complexity implications, this minimal description fails to provide adequate guidance 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?

The schema description coverage is 0%, but the description adds minimal value by implying the 'workflow_id' parameter is required for identification. However, it doesn't explain the parameter's format, constraints, or how to obtain valid IDs. With only one parameter and low schema coverage, the description partially compensates but leaves key semantics undocumented, meeting the baseline for minimal viability.

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 workflow by ID'), making the purpose unambiguous. It distinguishes itself from siblings like 'delete_asset' or 'delete_story' by specifying the workflow resource type. However, it doesn't explicitly differentiate from other workflow-related tools like 'update_workflow' or 'fetch_workflows' in terms of function, 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 no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing workflow ID), exclusions (e.g., not for bulk operations), or direct alternatives like 'bulk_delete_assets' for other resources. This leaves the agent without context for tool selection among the many delete-related siblings.

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 for behavioral disclosure. 'Duplicate a story' implies a write/mutation operation but reveals nothing about permissions needed, whether the duplicate inherits properties, what happens to the original, or what the output looks like. 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 extremely concise at just three words, front-loading the essential action. There's zero wasted language, making it efficient 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?

For a mutation tool with no annotations, no output schema, and 0% parameter documentation, the description is completely inadequate. It doesn't explain what duplication entails, what gets copied, permissions required, or what the result looks like, leaving critical gaps for agent understanding.

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 for its single parameter 'story_id', and the tool description provides no information about parameters. The description doesn't mention what 'story_id' represents, where to find it, or any constraints. With low schema coverage, the description fails 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 verb ('duplicate') and resource ('a story'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'create_story' or 'restore_story_version' that might also involve story creation/copying, so it doesn't reach the highest clarity level.

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 siblings like 'create_story', 'restore_story_version', and 'translate_story' that might overlap in functionality, there's no indication of when duplication is appropriate versus creating new or restoring previous versions.

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. 'List activity log' implies a read operation, but it doesn't disclose important behavioral traits: whether this requires authentication, what format the log entries have, if there are rate limits, whether results are paginated by default, or what happens with invalid parameters. The mention of 'Optional per_page, page, user_id' hints at pagination and filtering but doesn't explain 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 appropriately concise at 8 words. It's front-loaded with the core purpose ('List activity log') followed by parameter hints. Every word earns its place, though it could benefit from slightly more structure (e.g., separating purpose from parameters with punctuation).

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 3 parameters with 0% schema coverage, no annotations, and no output schema, the description is incomplete. It names parameters but doesn't explain their use, doesn't describe the return format, and provides no behavioral context for a data retrieval tool. For a tool that likely returns structured log data, this leaves 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?

Schema description coverage is 0%, so the schema provides no parameter documentation. The description mentions 'Optional per_page, page, user_id' which names the three parameters but adds minimal semantics: 'per_page' and 'page' suggest pagination, 'user_id' suggests filtering. However, it doesn't explain expected formats (numeric vs string), valid ranges, or how filtering works. With 3 undocumented parameters, this is inadequate compensation.

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

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

The description states 'List activity log' which provides a basic verb+resource combination, making the purpose understandable. However, it's vague about what 'activity log' contains and doesn't distinguish this from other list/fetch tools among the 50+ siblings. It's better than a tautology but lacks specificity about scope or content.

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 many other fetch_* tools (fetch_assets, fetch_stories, fetch_users, etc.), there's no indication of what makes 'activity log' distinct or when it should be preferred over other data retrieval tools. No exclusions or prerequisites are mentioned.

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

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

With no annotations provided, the description carries full burden but provides minimal behavioral information. It mentions pagination parameters but doesn't describe the return format, whether results are sorted, what permissions are required, or any rate limits. For a read operation with zero annotation coverage, this is inadequate.

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

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

The description is extremely concise with zero wasted words. It's front-loaded with the core purpose ('List asset folders') followed by parameter mention. Every sentence earns its place, though the brevity comes at the cost of completeness.

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

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

For a tool with 2 parameters, 0% schema coverage, no annotations, and no output schema, the description is incomplete. It doesn't explain what 'asset folders' are in this context, what the response looks like, or provide enough context for reliable tool selection and 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 documentation. The description mentions 'Optional per_page, page' which identifies the parameters but doesn't explain their purpose, valid ranges, or default values. It adds minimal semantic value beyond naming the 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 'List asset folders' clearly states the verb ('List') and resource ('asset folders'), but it's vague about scope - it doesn't specify if this lists all folders, only top-level folders, or folders with specific criteria. It distinguishes from obvious non-siblings like 'create_asset_folder' but doesn't differentiate from similar fetch tools like 'fetch_assets' or 'get_asset_folder'.

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 when this should be used instead of 'get_asset_folder' (singular) or how it differs from other fetch operations. The agent must infer usage from the name alone.

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

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

With no annotations, the description carries full burden but only states it's a list operation. It doesn't disclose behavioral traits like pagination defaults, rate limits, authentication needs, or what 'assets' includes (e.g., files, images). 'List' implies read-only, but this isn't explicitly confirmed.

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 lists parameters concisely, 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 list tool with 4 parameters, 0% schema coverage, no annotations, and no output schema, the description is incomplete. It lacks details on return values (e.g., asset structure), error handling, or prerequisites, leaving significant gaps for an 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 description must compensate. It lists parameters (folder_id, per_page, page, filter_query) but adds minimal meaning beyond names—no details on formats, defaults, or usage. For example, it doesn't explain what filter_query syntax is or if folder_id is optional for root assets.

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 'assets', making the purpose understandable. It doesn't distinguish from siblings like 'fetch_asset_folders' or 'get_asset', but it's not tautological or misleading.

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 vs. alternatives like 'get_asset' (for single asset) or 'fetch_asset_folders' (for folders). The description lists parameters but doesn't provide context or exclusions for 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?

With no annotations provided, the description carries full burden but only states it 'lists' folders without disclosing behavioral traits. It doesn't mention if this is a read-only operation, potential rate limits, authentication needs, or what the output looks like (e.g., format, pagination details), leaving significant 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 extremely concise with a single sentence that front-loads the core purpose and mentions parameters. There is no wasted text, making it efficient and well-structured for its brevity.

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

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

Given no annotations, 0% schema coverage, no output schema, and 2 parameters, the description is incomplete. It lacks details on behavior, parameter usage, and output, which are critical for a tool with undocumented inputs and no structured 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 but only names parameters ('per_page', 'page') without explaining their semantics (e.g., what 'per_page' means, default values, constraints). This adds minimal value beyond the bare schema, failing to address the coverage gap.

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

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

The description states the action ('List') and resource ('component folders'), which gives a basic understanding of purpose. However, it doesn't specify what 'list' entails (e.g., returns all folders, paginated results) or differentiate from sibling tools like 'fetch_components' or 'fetch_asset_folders', making it somewhat vague.

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. The description mentions optional parameters but doesn't explain context, prerequisites, or comparisons to similar tools like 'fetch_components', leaving the agent without 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 but offers minimal behavioral insight. It implies a read-only list operation but doesn't disclose pagination behavior (e.g., default values, limits), authentication needs, rate limits, error conditions, or return format. For a list tool with zero annotation coverage, this leaves significant gaps in understanding how it behaves.

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

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

The description is very concise with two sentences, front-loading the core purpose ('List components') and briefly noting parameters. There's no wasted text, though it could be structured more clearly (e.g., separating purpose from parameter notes).

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, no output schema, and a simple list operation with 2 parameters, the description is incomplete. It lacks details on pagination behavior, return format, error handling, and differentiation from siblings, making it inadequate for reliable tool selection and 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 but only partially does. It mentions 'Optional per_page, page' but doesn't explain what these parameters mean (e.g., per_page controls items per response, page selects result page), their expected formats, default values, or constraints. This 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 'List components' states the verb (list) and resource (components), making the basic purpose clear. However, it doesn't differentiate from sibling tools like 'get_component' (singular retrieval) or 'fetch_component_folders' (different resource type), leaving room for ambiguity about scope and relationship to other fetch 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. The description doesn't mention sibling tools like 'get_component' for single-component retrieval or 'fetch_component_folders' for folder-level operations, nor does it specify prerequisites, contexts, or exclusions for 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?

With no annotations provided, the description carries full burden but only states it's a list operation. It doesn't disclose behavioral traits like whether it's read-only, pagination behavior (implied by 'per_page' and 'page' but not explained), rate limits, authentication needs, or what the output looks like.

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 and lists optional parameters without unnecessary words. Every part earns its place, making it appropriately sized for a simple tool.

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

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

Given no annotations, no output schema, and 0% schema description coverage, the description is incomplete. It lacks details on behavior, output format, error handling, and usage context, which are critical for a tool with 4 parameters and list functionality.

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%, but the description mentions three optional parameters ('dimension', 'per_page', 'page'), adding some meaning beyond the bare schema. However, it doesn't explain what 'dimension' means or provide details on parameter usage, leaving gaps for the required 'datasource_id' and the others.

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 ('entries for a datasource'), making the purpose understandable. However, it doesn't differentiate from sibling tools like 'fetch_datasources' or 'get_datasource', which focus on datasources themselves rather than their entries.

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, such as needing an existing datasource, or compare it to similar tools like 'fetch_datasources' or 'create_datasource_entry'.

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 offers minimal behavioral insight. It mentions pagination parameters but doesn't disclose critical traits like whether this is a read-only operation, rate limits, authentication needs, or what the output format looks like (e.g., list 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 with just one sentence that front-loads the core purpose ('List datasources') followed by parameter mention. Every word serves a purpose, with no wasted text.

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 list operation with 2 parameters, 0% schema coverage, no annotations, and no output schema, the description is inadequate. It doesn't explain the return format, pagination behavior, or how it differs from similar fetch tools, 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?

Schema description coverage is 0%, so the description must compensate but only vaguely mentions 'Optional per_page, page' without explaining what these parameters do (e.g., per_page controls items per page, page selects page number). This 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 action ('List') and resource ('datasources'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'fetch_datasource_entries' or 'get_datasource', which might cause confusion about scope.

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

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

No guidance is provided about when to use this tool versus alternatives like 'get_datasource' (for a single datasource) or 'fetch_datasource_entries' (for entries within a datasource). The description only mentions optional parameters without context.

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

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

No annotations are provided, so the description carries full burden. It mentions optional pagination parameters but doesn't disclose behavioral traits like whether this is a read-only operation, what permissions are required, default pagination behavior, rate limits, or what the return format looks like. For a list operation with zero annotation coverage, this is inadequate.

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

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

The description is brief and front-loaded with the core purpose ('List releases'), followed by parameter mentions. It avoids unnecessary words, though it could be more structured (e.g., separating purpose from parameter notes).

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, no output schema, and 0% schema description coverage for a 2-parameter tool, the description is incomplete. It lacks essential context like return format, pagination defaults, error conditions, or how it differs from sibling 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 schema provides no parameter documentation. The description adds minimal value by naming the parameters ('per_page', 'page') but doesn't explain their purpose, expected values, defaults, or constraints (e.g., numeric ranges, typical usage). This doesn't 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 'List releases' states the basic action and resource, but is vague about scope and lacks differentiation from sibling tools like 'get_release' (singular) or 'fetch_activity_log' (different resource). It doesn't specify whether it lists all releases, recent releases, or releases with specific criteria.

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 'get_release' (singular fetch) and 'create_release'/'update_release'/'delete_release' (mutations), the description doesn't clarify that this is for listing multiple releases rather than fetching a specific one or performing mutations.

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 'List roles in the space,' which implies a read-only operation, but does not specify details like pagination, sorting, error handling, or authentication requirements. This leaves significant gaps in understanding how the tool behaves in practice.

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: 'List roles in the space.' It is front-loaded with the core action and resource, with no wasted words, making it highly 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 tool's simplicity (0 parameters, no output schema, no annotations), the description is minimally adequate but lacks depth. It covers the basic purpose but does not address behavioral aspects like return format or error conditions, which could be helpful for an agent despite the low complexity.

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%, so there is no need for parameter details in the description. The description appropriately avoids discussing parameters, aligning with the schema, which justifies a baseline score of 4 for not adding 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 roles in the space' clearly states the verb ('List') and resource ('roles in the space'), making the purpose specific and understandable. However, it does not explicitly distinguish this tool from similar sibling tools like 'fetch_users' or 'fetch_workflow_stages', which might also list entities, so it misses full 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. It lacks context such as prerequisites, when to prefer it over other fetch tools, or any exclusions, leaving usage unclear beyond the basic purpose.

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 'optional filters' but doesn't describe key behaviors like pagination defaults (implied by parameters but not explained), rate limits, authentication requirements, or what the output looks like (e.g., list format, error handling). This leaves significant gaps for a tool with 7 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 that front-loads the core purpose ('List stories') and enumerates parameters without unnecessary words. Every part serves a purpose, though it could be slightly more structured (e.g., grouping parameters by function).

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 (7 parameters, no annotations, no output schema), the description is incomplete. It lacks behavioral context (e.g., pagination behavior, error cases), doesn't explain parameter meanings, and provides no output information. For a list operation with many filters, this leaves 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?

The description lists 6 of the 7 parameters by name, adding value beyond the schema which has only 29% description coverage (only 'per_page' and 'page' have descriptions). However, it doesn't explain what these parameters mean (e.g., what 'with_slug' or 'is_startpage' do), so it partially compensates but doesn't fully bridge 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 verb ('List') and resource ('stories'), making the purpose unambiguous. However, it doesn't distinguish this from sibling tools like 'get_story' (which fetches a single story) or 'fetch_activity_log' (which lists different resources), so it misses full 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. It doesn't mention scenarios like retrieving multiple stories versus a single one (using 'get_story'), or how it differs from other list operations like 'fetch_assets'. There's no explicit when/when-not or alternative tool references.

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

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

No annotations are provided, so the description carries full burden. It states a read operation ('list'), but lacks details on permissions, rate limits, pagination, or return format. This is a significant gap for a tool with zero annotation coverage, making it minimally informative beyond the basic action.

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. It's front-loaded and efficiently conveys the core purpose, 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 tool's simplicity (0 parameters, no output schema, no annotations), the description is adequate but incomplete. It covers the basic action but lacks behavioral context (e.g., output structure, error handling). For a read-only tool with no complex schema, this is minimally viable but leaves 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 parameters with 100% coverage, so no parameter documentation is needed. The description doesn't add parameter details, which is appropriate, but it could have mentioned any implicit context (e.g., space ID), though not required. Baseline is 4 for zero 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 'List all tags in the space' clearly states the action (list) and resource (tags), with scope (in the space). It distinguishes from siblings like 'create_tag' or 'delete_tag', but not from other fetch tools (e.g., 'fetch_assets') in terms of resource type, which is acceptable given the naming convention.

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 explicit guidance on when to use this tool versus alternatives is provided. The description implies usage for retrieving tags, but it doesn't mention prerequisites, when not to use it, or compare with similar tools like 'fetch_tags' (if any duplicates) or other fetch 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?

No annotations are provided, so the description carries full burden. It implies a read operation ('List') but doesn't disclose behavioral traits like pagination defaults, rate limits, authentication needs, or what happens if no tasks exist. The description is minimal and leaves key behaviors 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 very concise—a single sentence with no wasted words. It's front-loaded with the core action ('List tasks') and lists parameters efficiently. However, it's so brief that it risks under-specification, slightly reducing its effectiveness.

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, no output schema, and 3 parameters, the description is incomplete. It lacks details on behavior, parameter usage, and output format, making it inadequate for a tool with multiple optional parameters. More context is needed 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. It lists parameters ('per_page, page, story_id') but adds no meaning beyond their names—no explanation of units, formats, or effects. For example, it doesn't clarify if 'story_id' filters tasks by story or if pagination is zero-based. This fails 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 states the verb 'List' and resource 'tasks', which provides a basic purpose. However, it's vague about scope (e.g., all tasks, filtered tasks) and doesn't differentiate from sibling tools like 'fetch_stories' or 'fetch_assets' beyond the resource name. It's functional but lacks specificity.

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. The description lists parameters but doesn't mention context like filtering by user, workspace, or status, or prerequisites. It's a bare listing without usage context.

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

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

No annotations are provided, so the description carries the full burden. It states 'List users' but doesn't disclose behavioral traits like pagination, rate limits, authentication needs, or what 'space' refers to. This is a significant gap for a read operation 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 with no wasted words. It's front-loaded with the core action and resource, 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's simplicity (0 parameters, no output schema, no annotations), the description is minimal. It lacks details on behavior, output format, or context like what 'space' means, making it incomplete for effective agent use despite the low complexity.

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 parameters with 100% coverage, so no parameter documentation is needed. The description adds no parameter info, which is acceptable here, but it doesn't compensate for any gaps since there are none. Baseline is 4 for zero 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 'List users in the space' clearly states the verb ('List') and resource ('users'), with 'in the space' providing context. It distinguishes from siblings like 'fetch_roles' or 'fetch_activity_log' by specifying users, though it doesn't explicitly contrast with similar tools like 'fetch_stories' or 'fetch_assets' 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?

No guidance is provided on when to use this tool versus alternatives. The description implies usage for retrieving user lists, but it doesn't specify prerequisites, constraints, or when other tools might be more appropriate, such as for filtering or detailed user data.

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 action ('List') but does not mention permissions, rate limits, pagination, or response format. This is inadequate 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 a single, efficient sentence with no wasted words, making it front-loaded and easy to parse. Every part contributes directly to stating the tool's purpose.

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

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

Given the tool's simplicity (0 parameters, no output schema) and lack of annotations, the description is minimally adequate but incomplete. It covers the basic action but omits behavioral details like response structure or constraints, which are needed for full 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 tool has 0 parameters with 100% schema description coverage, so no additional parameter information is needed. The description does not add semantics beyond the schema, but this is acceptable given the lack of parameters, aligning with the baseline for 0 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 ('List') and resource ('webhooks in the space'), making the purpose specific and understandable. However, it does not explicitly differentiate from sibling tools like 'get_webhook' (singular) or 'create_webhook', which could cause confusion in selection.

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 such as 'get_webhook' for a single webhook or 'create_webhook' for adding new ones. The description lacks context or exclusions, leaving usage decisions 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 full burden but only states the basic action without disclosing behavioral traits like pagination, sorting, filtering, rate limits, or authentication needs. It's minimal and lacks depth 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 a single, efficient sentence with no wasted words, making it easy to parse. It's appropriately sized for a simple tool with no 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 simplicity (0 parameters, no output schema), the description is minimally adequate but lacks context about the return format or any operational constraints. With no annotations, it should provide more behavioral insight 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?

The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description doesn't add parameter details, which is acceptable given the schema's completeness, aligning with the baseline for zero 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 ('List') and resource ('workflows in the space'), making the purpose understandable. However, it doesn't differentiate from sibling tools like 'fetch_workflow_stages' or 'get_workflow', which might cause confusion about scope.

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

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

No guidance is provided on when to use this tool versus alternatives such as 'get_workflow' or 'fetch_workflow_stages'. The description lacks context about use cases or prerequisites, leaving the agent without 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 listing but doesn't specify whether this is a read-only operation, what permissions are required, if there are rate limits, pagination behavior, or what format the output takes. 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 is a single, efficient sentence that gets straight to the point with zero wasted words. It's appropriately sized for a simple list operation and front-loads the 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?

For a tool with no annotations, 0% schema description coverage, and no output schema, the description is inadequate. It doesn't explain the single parameter, doesn't describe output format or behavior, and provides minimal context. Given the complexity of needing to understand what a workflow_id is and what stages are returned, more completeness 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 0%, so the single parameter 'workflow_id' is undocumented in the schema. The description adds no information about this parameter - no explanation of what a workflow_id is, where to find it, or format requirements. The description fails to compensate for the complete lack of schema documentation.

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

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 ('workflow stages for a workflow'), making the purpose immediately understandable. It doesn't explicitly distinguish from sibling tools like 'fetch_workflows' or 'get_workflow', but the specificity of 'stages' provides some 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 like 'fetch_workflows' or 'get_workflow', nor does it mention prerequisites or context for usage. It simply states what the tool does without indicating appropriate 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?

No annotations are provided, so the description carries full burden. It implies a read operation ('Get'), but doesn't disclose behavioral traits like whether it requires authentication, returns detailed metadata or just basic info, or handles errors (e.g., invalid ID). This leaves gaps for safe agent invocation.

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 waste, front-loaded with the core action. It's appropriately sized for a simple tool, though this conciseness contributes to gaps in other dimensions.

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, no output schema, and low schema coverage, the description is incomplete. It doesn't cover return values, error handling, or contextual nuances like asset types or permissions, making it inadequate for reliable agent use despite the tool's apparent simplicity.

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

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

Schema description coverage is 0%, with one parameter 'asset_id' undocumented in both schema and description. The description adds no meaning beyond the parameter name, failing to explain what an asset ID is, its format, or where to obtain it, which is critical for correct 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 states the verb ('Get') and resource ('asset'), but it's vague about what 'Get' entails (retrieve metadata, fetch content, etc.). It doesn't differentiate from siblings like 'fetch_assets' (plural) or 'update_asset', leaving ambiguity about scope.

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

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

No guidance is provided on when to use this tool versus alternatives. With siblings like 'fetch_assets' (for listing) and 'update_asset' (for modifications), the description lacks context on prerequisites, such as needing an asset ID, or exclusions, like not using it for bulk 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 full burden but only states the basic action. It doesn't disclose behavioral traits such as read-only nature (implied by 'Get'), error handling, authentication needs, rate limits, or what happens if the ID is invalid. This leaves significant gaps for a tool with no annotation coverage.

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

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

The description is a single, efficient sentence that front-loads the core action ('Get an asset folder by ID') with zero wasted words. It's appropriately sized for a simple retrieval tool.

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

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

Given no annotations, no output schema, and low schema coverage, the description is incomplete. It lacks details on return values, error conditions, or behavioral context needed for effective use, especially compared to richer sibling tools like 'fetch_asset_folders'.

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 meaning by specifying the parameter is an 'ID', which clarifies the purpose of 'asset_folder_id' beyond the schema's string type. With 0% schema description coverage and only one parameter, this adequately compensates, though it could detail ID format 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 verb ('Get') and resource ('asset folder'), specifying it retrieves by ID. It distinguishes from siblings like 'fetch_asset_folders' (plural) by focusing on a single folder, but doesn't explicitly contrast with 'get_asset' or other get_* 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 like 'fetch_asset_folders' (for listing) or 'get_asset' (for individual assets). The description implies usage when you have a specific folder ID, but lacks explicit context 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 full burden. It states 'Get' implies a read operation, but doesn't disclose behavioral traits like whether it requires authentication, returns detailed or summary data, handles errors (e.g., invalid ID), or has rate limits. For a read 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 a single, efficient sentence with zero waste—'Get a component by ID.' It is front-loaded and appropriately sized for a simple tool, avoiding unnecessary elaboration. Every word earns its place, 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 low complexity (1 parameter, no nested objects) but lack of annotations and output schema, the description is incomplete. It doesn't cover behavioral aspects (e.g., error handling, return format) or fully document the parameter. For a read tool in a context with many siblings, more guidance on usage and output would improve completeness.

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 mentions 'by ID' which clarifies the purpose of the 'component_id' parameter, adding meaning beyond the schema's type definition. However, it doesn't explain the parameter's format (e.g., string pattern), source, or constraints, leaving it partially documented.

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

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

The description clearly states the verb ('Get') and resource ('a component'), specifying it retrieves by ID. It distinguishes from siblings like 'fetch_components' (plural listing) and 'update_component' (modification), but doesn't explicitly contrast them. The purpose is specific and unambiguous, though not fully differentiated from similar tools.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'fetch_components' (for listing) or 'update_component' (for modification). It lacks context about prerequisites (e.g., needing a valid component ID) or exclusions (e.g., not for creating components). 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?

With no annotations provided, the description carries full burden for behavioral disclosure. 'Get' implies a read operation, but the description doesn't specify whether this requires authentication, what happens if the ID doesn't exist, whether it returns all fields or a subset, or any rate limits. For a read 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 wasted words. It's appropriately sized for a simple retrieval tool and front-loads the essential information immediately.

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

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

For a retrieval tool with no annotations, no output schema, and 0% schema description coverage, the description is inadequate. It doesn't explain what information is returned, error conditions, authentication requirements, or how this differs from bulk fetch operations. The context signals indicate this tool needs more complete documentation.

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 single parameter 'datasource_id' is completely undocumented in the schema. The description mentions 'by ID' which provides minimal context about the parameter's purpose, but doesn't specify format (e.g., UUID, numeric), where to find IDs, or validation rules. It adds some meaning but doesn't adequately compensate for 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 action ('Get') and resource ('a datasource by ID'), making the purpose immediately understandable. It doesn't differentiate from siblings like 'fetch_datasources' or 'create_datasource', but the verb+resource combination is specific enough for basic understanding.

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 'fetch_datasources' (which likely lists multiple datasources) or 'create_datasource'. There's no mention of prerequisites, error conditions, or typical use cases for retrieving a single datasource by ID.

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 states a read operation ('Get'), implying it's non-destructive, but doesn't disclose behavioral traits like authentication needs, rate limits, error handling, or what happens if the ID is invalid. For a tool with zero annotation coverage, this is inadequate.

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

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

The description is a single, efficient sentence with zero waste. It's front-loaded and appropriately sized for a simple retrieval tool, 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 no annotations, 0% schema coverage, and no output schema, the description is incomplete. It lacks details on behavior, parameter usage, return values, and error cases, which are critical for a tool with one required parameter and no structured documentation.

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 mentions 'by ID', which adds meaning to the 'release_id' parameter, but doesn't explain the ID format, source, or constraints. This partially compensates but leaves significant 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 verb ('Get') and resource ('a release by ID'), making the purpose specific and understandable. It distinguishes from siblings like 'fetch_releases' (plural) by focusing on single retrieval, though it doesn't explicitly contrast with them.

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 'fetch_releases' or 'get_story'. The description implies usage when you have a specific release ID, but offers no explicit context, 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 full burden. It states it retrieves details but doesn't disclose behavioral traits like whether it's a read-only operation, requires authentication, has rate limits, or what format/details are returned. 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 a single, efficient sentence that front-loads the core purpose ('Get the current space details') and adds necessary context ('the one from STORYBLOK_SPACE_ID') without any wasted words. Every part earns its place.

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

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

Given 0 parameters and 100% schema coverage, the input side is well-covered. However, with no annotations and no output schema, the description doesn't explain what 'details' are returned or any behavioral constraints. For a simple retrieval tool, it's minimally adequate but leaves the agent guessing about the response format and 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?

The tool has 0 parameters with 100% schema description coverage, so the schema fully documents the lack of inputs. The description adds value by specifying that it retrieves details for 'the one from STORYBLOK_SPACE_ID', clarifying that the space is determined by an environment variable rather than a parameter. This compensates adequately for the simple parameter case.

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 ('current space details'), specifying it retrieves the space identified by STORYBLOK_SPACE_ID. It distinguishes from siblings like 'update_space' (which modifies) and 'fetch_*' tools (which list multiple items), but doesn't explicitly contrast with other single-item retrieval tools like 'get_story' or 'get_asset'.

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 explicit guidance on when to use this tool versus alternatives is provided. The description implies it's for retrieving details of a specific space, but doesn't clarify if this is the only way to get space information or when to choose it over other tools like 'fetch_*' for listing spaces (though no such sibling exists in the 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 full burden for behavioral disclosure. It states a read operation ('Get'), implying safety, but doesn't cover permissions, error handling (e.g., invalid UUID), rate limits, or response format. 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 is a single, efficient sentence with zero waste. It's front-loaded with the core purpose and includes essential detail (UUID). Every word earns its place, 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 no annotations, no output schema, and low schema coverage (0%), the description is incomplete. It lacks details on permissions, error cases, response structure, and differentiation from siblings. For a read tool in a complex system with many siblings, more context is needed to ensure reliable 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%, with one parameter ('story_id') undocumented in the schema. The description adds minimal semantics by specifying it's a 'UUID', clarifying the expected format beyond just a string. However, it doesn't explain where to find the UUID or provide examples, leaving some ambiguity.

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 ('a single story'), specifying retrieval by UUID. It distinguishes from sibling 'fetch_stories' (plural) by emphasizing single-item retrieval, though it doesn't explicitly mention the sibling. The purpose is specific and unambiguous.

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

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

No guidance is provided on when to use this tool versus alternatives like 'fetch_stories' (for multiple stories) or 'get_story_versions' (for version history). The description implies usage for retrieving a specific story by ID, but lacks explicit comparison or exclusion criteria for sibling 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states 'List versions' but doesn't describe what a 'version' includes (e.g., metadata, content changes), how results are formatted (e.g., list, paginated), or any constraints (e.g., permissions, rate limits). For a read operation with zero annotation coverage, this leaves significant gaps in understanding the tool's 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 ('List versions of a story.') that is front-loaded with the core action and resource. There is zero wasted text, and it directly communicates the tool's function without unnecessary elaboration, making it highly concise 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 no annotations, 0% schema coverage, and no output schema, the description is incomplete for a tool with one parameter. It lacks details on behavior (e.g., output format, error handling), parameter semantics, and usage context. While concise, it doesn't provide enough information for an agent to confidently invoke the tool without additional assumptions.

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 mentions 'a story' which implies the 'story_id' parameter, adding minimal semantic context. However, it doesn't explain what a 'story_id' is (e.g., format, source) or any validation rules. With one undocumented parameter, the description partially compensates but doesn't fully clarify parameter meaning.

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 versions of a story' clearly states the verb ('List') and resource ('versions of a story'), making the purpose immediately understandable. It distinguishes from siblings like 'get_story' (which fetches a single story) and 'fetch_stories' (which lists multiple stories), though it doesn't explicitly mention this differentiation. The purpose is specific but could be slightly more precise about what 'versions' entails.

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 story_id), exclusions, or related tools like 'restore_story_version' (which operates on versions) or 'get_story' (which might return current version). Usage is implied by the name and purpose, but no explicit context 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Get' implies a read-only operation, but it doesn't specify whether authentication is required, what happens if the ID is invalid (e.g., error handling), or the format of the returned data. 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 a single, efficient sentence that front-loads the core purpose without unnecessary words. Every part of the sentence ('Get a webhook by ID') contributes directly to understanding the tool's function, making it appropriately sized 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 complexity (a read operation with one parameter), lack of annotations, and no output schema, the description is incomplete. It doesn't cover behavioral aspects like error handling, authentication needs, or return format, which are crucial for an agent to use the tool effectively. The minimal description leaves too many contextual 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 description mentions 'by ID', which aligns with the single parameter 'webhook_id' in the schema. However, schema description coverage is 0%, so the schema provides no details about the parameter. The description adds minimal semantics by indicating the parameter is an ID, but doesn't specify format, constraints, or examples, leaving the agent with incomplete 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 'Get a webhook by ID' clearly states the verb ('Get') and resource ('webhook'), making the purpose immediately understandable. It distinguishes from sibling tools like 'fetch_webhooks' (plural) by specifying retrieval of a single webhook via ID. However, it doesn't explicitly contrast with other webhook-related tools like 'create_webhook' or 'delete_webhook', though the verb 'Get' implies read-only retrieval.

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 sibling tools like 'fetch_webhooks' for listing multiple webhooks or 'get_webhook' for retrieving a specific one by ID, nor does it specify prerequisites such as needing a valid webhook ID. Usage is implied by the name and description 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action ('Get') but doesn't describe traits like whether it's read-only, requires authentication, handles errors, or returns specific data formats. This is a significant gap 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 extremely concise and front-loaded in a single sentence, with zero wasted words. It directly communicates the core action without unnecessary elaboration, 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 tool's simplicity (1 parameter, no output schema, no annotations), the description is incomplete. It doesn't address behavioral aspects, error handling, or return values, which are crucial for effective use. While concise, it lacks the depth needed for a tool with no structured support, leaving gaps in understanding.

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 meaning beyond the input schema, which has 0% description coverage. It implies 'workflow_id' is required but doesn't explain its format, constraints, or source. With one parameter and low schema coverage, the description partially compensates but lacks depth, aligning with the baseline for adequate but incomplete 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 ('Get') and resource ('workflow by ID'), making the purpose specific and understandable. It distinguishes from siblings like 'fetch_workflows' (plural) by focusing on a single workflow retrieval, though it doesn't explicitly contrast with other get_* tools (e.g., 'get_story').

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

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

No guidance is provided on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a workflow ID), exclusions, or comparisons to similar tools like 'fetch_workflows' for listing workflows, leaving usage context implied but unspecified.

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 lists tools 'by category' and 'No API call,' which adds useful context about organization and local operation. However, it lacks details on output format (e.g., structure of the list), potential errors, or performance implications, leaving 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 extremely concise and front-loaded: a single sentence that directly states the tool's purpose and key behavioral constraint ('No API call'). Every word earns its place, with no wasted text or 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?

Given the tool's simplicity (0 parameters, no output schema, no annotations), the description is adequate but has clear gaps. It explains what the tool does and its local nature, but without annotations or output schema, it should ideally describe the return format (e.g., how tools are categorized). The description is minimal but functional for a low-complexity tool.

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

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

The tool has 0 parameters, and schema description coverage is 100% (though empty). The description does not need to explain parameters, and it appropriately avoids redundant information. A baseline of 4 is applied since no parameters exist, and the description adds value by clarifying the tool's scope without over-explaining.

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 available Storyblok MCP tools by category.' It specifies the verb ('List'), resource ('Storyblok MCP tools'), and scope ('by category'), which is specific and actionable. However, it does not explicitly distinguish this tool from its many siblings (e.g., other fetch_* tools), 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 usage guidance: 'No API call.' This clearly indicates when to use this tool (for local tool discovery without external requests) versus alternatives (sibling tools that make API calls). It effectively distinguishes this tool's context from others in the server.

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 the tool verifies the environment and optionally the API, but doesn't disclose behavioral traits like what 'verifies' entails (e.g., returns status codes, error messages), whether it's safe or has side effects, or any rate limits. The description is minimal and leaves key operational details 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 appropriately sized and front-loaded: two sentences that directly state the purpose and parameter usage with zero waste. Every sentence earns its place by providing 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 low complexity (1 optional parameter, no output schema, no annotations), the description is somewhat complete but has gaps. It explains the basic purpose and parameter, but lacks details on return values, error handling, or behavioral context. For a health check tool, more information on expected outputs or failure modes would improve completeness.

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 description compensates by explaining the parameter's purpose: 'Set check_api=1 to call the API.' This adds meaning beyond the schema, clarifying that the parameter is optional (since required parameters are 0) and triggers an API check. However, it doesn't detail other possible values or effects, so it's not a full 5.

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

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

The description clearly states the tool's purpose: 'Health check. Verifies env and optionally the Storyblok API.' It specifies the verb ('verifies') and the resources (environment and API), making it distinct from sibling tools that perform CRUD operations on assets, stories, etc. However, it doesn't explicitly differentiate from other diagnostic tools (none are listed among siblings), so it's not a perfect 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 implies usage by stating 'Set check_api=1 to call the API,' which suggests this tool is for verifying system health, with an optional API check. However, it doesn't provide explicit guidance on when to use this tool versus alternatives (e.g., for troubleshooting vs. regular monitoring) or any prerequisites. The context is clear but lacks detailed exclusions or comparisons.

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 offers minimal behavioral insight. It implies a write operation ('Publish') but doesn't disclose permissions needed, whether it's idempotent, what happens on success/failure, or side effects (e.g., making story publicly available). It lacks critical context 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 very concise with two brief sentences, front-loading the main action. However, it's arguably too terse given the complexity of a publishing operation with multiple parameters, lacking necessary explanatory content.

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 3 parameters, 0% schema coverage, no annotations, and no output schema, the description is inadequate. It doesn't explain the publishing process, return values, error conditions, or how it interacts with sibling tools like 'unpublish_story'. More context is needed 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 schema provides no parameter documentation. The description mentions 'Optional lang, release_id' but doesn't explain what these parameters mean, their formats, or how they affect publishing. It adds minimal value beyond naming two optional parameters, leaving 'story_id' and all semantics undocumented.

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 ('Publish a story') which is a clear verb+resource combination, but it doesn't differentiate from sibling tools like 'unpublish_story' or explain what publishing entails in this context. It's vague about the specific action beyond the basic verb.

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

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

No guidance is provided on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., story must exist), conditions for publishing, or differences from related tools like 'update_story' or 'create_release'. The description only lists optional parameters without context.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure but offers none. It doesn't indicate whether this is a destructive mutation (likely, given 'restore'), what permissions are required, how it affects the current story state, or what the expected outcome is. Critical behavioral traits like side effects, error conditions, or success indicators are completely absent.

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 with no wasted words. It is front-loaded with the core action, though this brevity comes at the cost of completeness. Every word earns its place by stating the essential function, albeit minimally.

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 mutation tool with no annotations, 0% schema coverage, no output schema, and multiple sibling tools), the description is severely incomplete. It lacks purpose differentiation, usage guidelines, behavioral context, parameter details, and output information, making it inadequate for effective tool invocation by an 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 but fails to do so. It mentions no parameters at all, leaving both 'story_id' and 'version_id' entirely undocumented in meaning, format, or source. The description adds zero semantic value beyond the bare parameter names in the schema.

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

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

The description 'Restore a story version' is a tautology that essentially restates the tool name. While it indicates the action (restore) and target (story version), it provides no additional specificity about what restoration entails or how it differs from related tools like 'bulk_restore_assets' or 'get_story_versions'. The purpose is minimally stated but lacks meaningful 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. There are no mentions of prerequisites (e.g., needing existing versions), exclusions, or comparisons to sibling tools like 'bulk_restore_assets' or 'get_story_versions'. The agent receives no contextual cues for appropriate tool selection.

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

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

No annotations are provided, so the description carries the full burden. It states the tool uses AI for translation, which implies potential latency or quality variations, but doesn't disclose other behavioral traits like whether it modifies the original story, creates a new version, requires specific permissions, has rate limits, or what the output looks like. For a mutation tool with zero annotation coverage, this is inadequate.

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

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

The description is very concise with two short sentences, front-loading the main purpose. There's no unnecessary information, but it might be overly brief given the lack of detail in other dimensions. Every sentence serves a purpose, though more could be added 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 of a translation operation (likely a mutation), no annotations, no output schema, and low schema coverage, the description is incomplete. It doesn't cover key aspects like what the tool returns, error conditions, or how it interacts with the story system. For a tool with 2 parameters and no structured support, 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?

Schema description coverage is 0%, so the schema provides no parameter details. The description only mentions 'Optional lang_code', ignoring the required 'story_id' parameter. It doesn't explain what 'story_id' refers to, what format 'lang_code' should be in (e.g., ISO codes), or default behaviors. This fails to compensate for the low schema coverage.

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

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

The description clearly states the action ('Translate') and the resource ('a story'), specifying it uses AI. It distinguishes from siblings like 'create_story' or 'update_story' by focusing on translation rather than creation or modification. However, it doesn't explicitly differentiate from tools like 'duplicate_story' in terms of language transformation vs. content copying.

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 mentions 'Optional lang_code' but doesn't explain when to include it, what happens if omitted, or how this differs from other story-related operations like 'duplicate_story' or 'publish_story'. There's no context about prerequisites or typical use 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?

With no annotations provided, the description carries full burden for behavioral disclosure. It states the action ('Unpublish') which implies a mutation, but doesn't disclose any behavioral traits: no mention of permissions required, whether the action is reversible, what happens to the story's status, rate limits, or error conditions. The optional 'lang' parameter hints at localization but isn't explained.

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 - just two brief sentences that get straight to the point. Every word serves a purpose: the first sentence states the core functionality, the second mentions an optional parameter. There's no fluff or unnecessary elaboration, 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, no output schema, and 2 parameters (one required), the description is incomplete. It doesn't explain what 'unpublishing' entails operationally, what the expected outcome is, error scenarios, or the effect of the optional 'lang' parameter. The agent would need to guess about important behavioral aspects of this destructive 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 but adds minimal value. It mentions 'Optional lang' which corresponds to one parameter, but doesn't explain what 'lang' represents (language code? locale?) or its effect. The required 'story_id' parameter gets no mention at all. With 2 parameters and 0% schema coverage, this leaves significant 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 action ('Unpublish') and resource ('a story'), making the purpose immediately understandable. It distinguishes from siblings like 'delete_story' or 'restore_story_version' by focusing on unpublishing rather than deletion or restoration. However, it doesn't explicitly contrast with 'publish_story' beyond the obvious inverse relationship.

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., story must be published first), consequences (e.g., what happens to published content), or when to choose 'unpublish_story' over 'delete_story' or other story-related operations. The single sentence offers only basic functionality without context.

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

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

No annotations are provided, so the description carries full burden. It states 'update' which implies mutation, but doesn't disclose behavioral traits like permission requirements, whether changes are reversible, rate limits, or what happens to unspecified fields. For a mutation tool with zero annotation coverage, this leaves significant gaps in understanding the tool's 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 front-loads the core purpose. The 'etc.' at the end is slightly vague but keeps it concise. No wasted words, though it could be more structured with bullet points for the field examples.

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 6 parameters, 0% schema coverage, no annotations, and no output schema, the description is inadequate. It should explain more about the update operation (e.g., partial vs. full updates, error conditions, response format). The current description leaves too many contextual gaps for 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 documentation. The description lists examples of updatable fields (filename, asset_folder_id, alt, title, copyright) which helps interpret some of the 6 parameters, but doesn't cover all parameters (e.g., asset_id is required but not mentioned) or provide format details. It adds marginal value but doesn't fully compensate for 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 verb 'update' and resource 'asset metadata', and lists specific fields that can be updated (filename, asset_folder_id, alt, title, copyright). It distinguishes from sibling tools like 'delete_asset' or 'get_asset' by specifying it's for metadata updates rather than deletion or retrieval. However, it doesn't explicitly differentiate from other update tools like 'update_asset_folder'.

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 asset), when not to use it (e.g., for creating new assets), or compare it to sibling tools like 'bulk_move_assets' or 'update_story'. The agent must infer usage from the tool name and context alone.

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

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. 'Update' implies a mutation operation, but the description doesn't specify whether this requires special permissions, what happens to child assets when moving folders, whether changes are reversible, or what the response contains. For a mutation tool with zero annotation coverage, 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.