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

With no annotations provided, the description carries the full burden and discloses key behavioral traits: it mentions a cost ('Costs 5 credits'), which is a rate limit or resource constraint, and describes the state change and subsequent action ('article writing begins'). This adds valuable context beyond basic functionality.

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

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

The description is front-loaded with the core action and cost, followed by the outcome, in two efficient sentences with zero waste. Every sentence earns its place by providing 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 complexity (a mutation tool with cost implications), no annotations, and no output schema, the description is fairly complete: it covers purpose, cost, and behavioral outcome. However, it could improve by detailing error cases or response format, leaving minor gaps for an agent's full 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 input schema has 100% description coverage, clearly documenting both parameters (workspace_id and suggestion_id) as UUIDs. The description doesn't add any meaning beyond the schema, such as explaining parameter relationships or usage nuances, so it meets the baseline for high schema coverage.

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

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

The description clearly states the action ('accept a suggestion') and the outcome ('suggestion status changes to "accepted" and article writing begins'), which specifies the verb and resource. However, it doesn't explicitly differentiate from its sibling 'reject_suggestion' beyond the opposite action, missing a direct comparison.

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 mentioning the outcome of accepting a suggestion, but it doesn't provide explicit guidance on when to use this tool versus alternatives like 'reject_suggestion' or other creation tools. It lacks context on prerequisites or scenarios 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions a cost ('Costs 5 credits') and immediate action ('Article writing starts immediately'), which are useful. However, it lacks details on permissions, error handling, rate limits, or what 'briefing' entails beyond starting article writing, making it insufficient 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 concise with two sentences that directly state the purpose and key behavioral aspects (cost and immediacy). It is front-loaded with the main action, though it could be slightly more structured by separating cost and timing into distinct points.

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 (11 parameters, mutation tool) and no annotations or output schema, the description is moderately complete. It covers purpose and some behavioral traits but lacks details on output, error cases, or deeper context about the briefing creation process, leaving 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 100%, so the schema already documents all 11 parameters thoroughly. The description adds no additional parameter semantics beyond implying 'topic' is required and that parameters relate to article creation. This meets the baseline for high schema coverage.

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

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

The description clearly states the tool's purpose: 'Create a briefing to directly start writing an article on a given topic.' It specifies the verb ('create'), resource ('briefing'), and outcome ('start writing an article'). However, it doesn't explicitly differentiate from sibling tools like 'get_briefing' or 'list_briefings' beyond the creation aspect.

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

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

The description implies usage context by stating 'Article writing starts immediately' and mentions a cost ('Costs 5 credits'), which suggests when to use it. However, it doesn't provide explicit alternatives (e.g., when to use 'generate_suggestions' or 'get_briefing' instead) or clear exclusions, leaving some ambiguity.

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 write operation ('Add'), but doesn't disclose behavioral traits such as permissions required, whether duplicates are allowed, error handling, or what happens on success (e.g., returns a competitor ID). This is a significant gap for a mutation tool with zero annotation coverage.

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

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

The description is a single, efficient sentence that front-loads the core purpose without unnecessary words. Every part earns its place by specifying the action, resource, target, and purpose concisely.

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 is a mutation (create operation) with no annotations and no output schema, the description is incomplete. It lacks behavioral context (e.g., side effects, response format) and usage guidelines, which are critical for an agent to invoke it correctly. The high schema coverage helps with parameters, but overall context is insufficient.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters (workspace_id, name, domain) with basic descriptions. The description adds no additional meaning beyond implying the domain is for analysis, but doesn't provide syntax, format details, or constraints beyond what the schema states. Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description clearly states the action ('Add') and resource ('competitor domain to a workspace'), specifying it's for 'content strategy analysis'. It distinguishes from siblings like 'delete_competitor' by the verb, but doesn't explicitly differentiate from other 'create_' tools (e.g., 'create_keyword') 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. It doesn't mention prerequisites (e.g., workspace existence), exclusions, or compare to siblings like 'list_competitors' or 'update_workspace', leaving the agent to infer usage context solely from the tool name and description.

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 that 'A connection test runs automatically after creation,' which is valuable behavioral context. However, it doesn't disclose important traits like whether this is a mutating operation (implied but not stated), what permissions are required, error handling, or what happens if the connection test fails. For a creation tool with complex parameters and no annotations, this is insufficient.

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

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

The description is extremely concise - just two sentences that efficiently convey the core purpose, required inputs (credentials), automatic behavior (connection test), and supported services. Every word earns its place with zero waste or redundancy.

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

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

Given the tool's complexity (22 parameters, creation operation) and absence of both annotations and output schema, the description is incomplete. It doesn't explain what the tool returns, what happens on success/failure, authentication requirements, or error conditions. For a tool that creates integrations with multiple service configurations, more contextual information would be helpful 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 100%, so the schema already documents all 22 parameters thoroughly with service-specific groupings. The description adds minimal value beyond the schema by listing the supported services, but doesn't provide additional semantic context about parameter relationships, dependencies, or usage patterns. The baseline of 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the tool creates a publishing integration and lists supported services, providing a specific verb (create) and resource (publishing integration). However, it doesn't explicitly differentiate from sibling tools like 'update_integration' or 'reconnect_integration' beyond the obvious 'create' vs 'update/reconnect' 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 implies usage context by stating 'Provide service-specific credentials' and listing supported services, suggesting this should be used when setting up new publishing integrations. However, it doesn't provide explicit guidance on when to use this vs alternatives like 'update_integration' or 'reconnect_integration', nor does it mention prerequisites or when-not-to-use 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, the description carries full burden. It states the tool creates a keyword and fetches data automatically, which hints at a write operation and external API calls. However, it lacks details on permissions, side effects, error handling, or rate limits, leaving 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 concise and front-loaded, stating the core purpose in the first sentence. The second sentence adds value by explaining automatic data fetching, avoiding redundancy. It could be slightly more structured but remains efficient with no wasted words.

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

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

Given no annotations and no output schema, the description is moderately complete for a simple creation tool. It covers the basic action and outcome but lacks details on return values, error cases, or integration with sibling tools, leaving room for improvement in contextual depth.

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

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

Schema description coverage is 100%, providing clear parameter details. The description adds minimal semantics by implying 'name' is the keyword text and that data is fetched post-creation, but doesn't elaborate beyond the schema's descriptions. Baseline 3 is appropriate as the schema handles most 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 ('Add a new keyword') and resource ('to the workspace'), specifying it's for creation. It distinguishes from siblings like 'delete_keyword' or 'list_keywords' by focusing on addition, but doesn't explicitly contrast with similar creation tools like 'create_workspace' or 'create_briefing'.

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. It mentions automatic data fetching, which implies usage for keyword setup, but lacks context on prerequisites, timing, or comparisons to siblings like 'generate_suggestions' or 'generate_long_tail_keywords' for keyword-related tasks.

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

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

With no annotations provided, the description carries full burden. It states the tool adds a link and that scraping occurs, but doesn't disclose behavioral traits like required permissions, rate limits, whether the operation is idempotent, error conditions, or what happens if the URL is invalid. For a mutation tool with zero annotation coverage, this leaves 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 two concise sentences with zero waste. It front-loads the core purpose and adds useful context about scraping and article writing. Every sentence earns its place by providing distinct information.

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

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

Given this is a mutation tool with no annotations and no output schema, the description is incomplete. It doesn't cover what the tool returns, error handling, side effects, or dependencies. For a tool that modifies workspace state, more behavioral context is needed to be fully helpful to 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 100%, so the schema already documents both parameters (workspace_id as UUID, url as link URL). The description adds minimal value beyond the schema—it implies the URL is scraped for content, but doesn't provide additional syntax, format details, or constraints. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the action ('Add a reference link') and the resource ('to the workspace'), and mentions that Balzac will scrape the URL for article writing. It distinguishes from siblings like delete_link by specifying creation, but doesn't explicitly differentiate from other create_* tools 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 explicit guidance on when to use this tool versus alternatives is provided. It doesn't mention prerequisites, when not to use it, or compare it to similar tools like create_integration or create_workspace. The context is implied (adding links for article writing) but lacks actionable usage rules.

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 and adds valuable behavioral context: it discloses that the tool triggers automatic site analysis and keyword discovery, mentions the 'analyzing' status during setup, and notes that it 'Costs no credits.' This covers key operational aspects like process initiation, state changes, and cost implications, though it could elaborate on permissions or error handling.

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

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

The description is front-loaded with the core purpose and key behavior in the first sentence, followed by status and cost details. It uses three concise sentences with zero waste, efficiently conveying 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 complexity (9 parameters, creation operation) and lack of annotations or output schema, the description does well by explaining the creation process, automatic analysis, status changes, and cost. However, it could be more complete by mentioning potential errors, response format, or integration with sibling tools like 'list_workspaces' for verification.

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

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

Schema description coverage is 100%, so the schema already documents all 9 parameters thoroughly. The description adds minimal parameter semantics by emphasizing the 'domain' parameter as the primary input for website analysis, but does not provide additional meaning beyond what the schema descriptions offer. Baseline 3 is appropriate given high schema coverage.

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

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

The description clearly states the specific action ('Create a new workspace'), the required resource ('by providing a website domain'), and the automatic behavior ('analyze the site and discover keywords'). It distinguishes from siblings like 'update_workspace' or 'list_workspaces' by focusing on creation with automated analysis.

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

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

The description implies usage when a new workspace is needed for website analysis, but does not explicitly state when to use this versus alternatives like 'update_workspace' or prerequisites. It mentions the workspace status 'analyzing' until setup completes, which provides some context, but lacks explicit guidance on when-not-to-use or comparisons with 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?

With no annotations provided, the description carries full burden for behavioral disclosure. While 'permanently delete' clearly indicates a destructive, irreversible operation, it doesn't address important aspects like required permissions, confirmation mechanisms, error handling, or what happens to associated data. The description is minimal and misses key behavioral context.

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

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

The description is extremely concise - a single three-word phrase that communicates the essential action. There's zero wasted language, and it's perfectly front-loaded with the most critical information ('permanently delete').

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 inadequate. It doesn't explain what 'permanently' entails, whether there are recovery options, what the response looks like, or any error conditions. Given the high-stakes nature of deletion operations, more context is needed.

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

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

The description adds no parameter information beyond what's already in the schema (which has 100% coverage). The schema fully documents both required parameters (workspace_id and article_id) with clear descriptions. The description doesn't provide additional context about parameter relationships or usage patterns.

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

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

The description clearly states the action ('permanently delete') and resource ('an article'), making the purpose immediately understandable. It doesn't explicitly differentiate from sibling deletion tools like delete_competitor or delete_workspace, but the specificity of 'article' provides inherent 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_article, schedule_article, or other deletion tools. There's no mention of prerequisites, consequences, or appropriate contexts for this destructive operation.

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 ('Remove') without disclosing behavioral traits. It doesn't mention if deletion is permanent, requires specific permissions, has side effects (e.g., removing associated data), or provides confirmation. This leaves critical gaps 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 wasted words. It's front-loaded with the core action and resource, making it highly efficient and easy to parse 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 and no output schema, the description is incomplete. It lacks details on behavior (e.g., confirmation, error handling), output expectations, or integration with sibling tools like 'list_competitors'. Given the complexity of deletion, more context is needed.

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

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

Schema description coverage is 100%, so the schema fully documents both parameters (workspace_id and competitor_id as UUIDs). The description adds no parameter-specific information beyond implying these are needed for deletion, meeting the baseline for high schema coverage without extra value.

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

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

The description clearly states the action ('Remove') and resource ('a competitor from the workspace'), making the purpose unambiguous. It distinguishes from siblings like 'delete_article' or 'delete_workspace' by specifying the competitor resource, but doesn't explicitly contrast with alternatives like 'disable_keyword' for similar operations.

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

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

No guidance is provided on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing to list competitors first), consequences (e.g., irreversible deletion), or related tools like 'list_competitors' for reference. The description is standalone 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. While 'Delete' implies a destructive operation, it doesn't specify whether this action is reversible, what permissions are required, whether it affects associated data, or what happens after deletion (e.g., confirmation message, error handling). The description provides minimal behavioral context 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, efficient sentence that gets straight to the point with zero wasted words. It's appropriately sized for a simple deletion operation and is perfectly front-loaded with 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 destructive operation with no annotations and no output schema, the description is insufficient. It doesn't explain what 'publishing integration' means in this context, what gets deleted (just configuration or also published content?), whether there are confirmation steps, or what the tool returns. Given the complexity of a deletion operation, more context is needed.

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

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

Schema description coverage is 100%, so the schema already documents both parameters (workspace_id and integration_id) as UUIDs. The description doesn't add any parameter-specific information beyond what's in the schema, such as where to find these IDs or format requirements. This meets the baseline for high schema coverage.

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

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

The description clearly states the action ('Delete') and resource ('a publishing integration'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'delete_workspace' or 'delete_integration' (which appears to be itself - possibly a typo in sibling list) by specifying what makes this deletion unique.

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

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

No guidance is provided about when to use this tool versus alternatives. The description doesn't mention prerequisites (e.g., needing an existing integration), consequences of deletion, or when to choose this over other deletion tools like 'delete_workspace' or 'reconnect_integration' for integration-related actions.

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

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

No annotations are provided, so the description carries full burden. It states the tool deletes a keyword, implying a destructive mutation, but fails to disclose critical behavioral traits such as permission requirements, irreversibility, effects on related data, or error handling. 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 wasted words, making it highly efficient and front-loaded. It immediately conveys 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 tool with no annotations and no output schema, the description is incomplete. It lacks essential context like success/error responses, side effects, or safety warnings, leaving the agent underinformed about the tool's behavior and outcomes.

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

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

Schema description coverage is 100%, with both parameters ('workspace_id' and 'keyword_id') documented as UUIDs. The description adds no additional meaning beyond the schema, such as format details or usage examples, but the high coverage justifies the baseline score of 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 keyword from the workspace'), making the purpose immediately understandable. It distinguishes from siblings like 'disable_keyword' by specifying deletion rather than disabling, though it doesn't explicitly contrast with all deletion tools (e.g., 'delete_article').

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 'disable_keyword' or other deletion tools. The description lacks context about prerequisites, consequences, or typical scenarios for deletion, 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 the full burden of behavioral disclosure. It states 'Remove' (implying a destructive mutation) but doesn't clarify if this is permanent, reversible, requires specific permissions, or has side effects (e.g., affecting linked content). 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 with zero waste—it directly states the tool's action and target. It's appropriately sized for a simple deletion tool and front-loaded with 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 destructive mutation tool with no annotations and no output schema, the description is incomplete. It lacks details on behavior (e.g., permanence, error handling), prerequisites, or return values. Given the complexity and lack of structured data, more context is needed to adequately guide 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 100%, so the schema already documents both parameters (workspace_id and link_id) as UUIDs. The description adds no additional meaning beyond implying these parameters identify the target link, which is already clear from the schema. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the action ('Remove') and target resource ('a reference link from the workspace'), making the purpose immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'delete_article' or 'delete_workspace' beyond the resource type, missing an opportunity for clearer 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 (e.g., needing an existing link), exclusions, or comparisons to similar tools like 'delete_article' or 'list_links' for verification. 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, the description carries full burden. It discloses the irreversible nature ('permanently') and scope ('all its data'), which is critical for a destructive operation. However, it lacks details on permissions needed, confirmation steps, error conditions, or what happens to dependent resources.

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 front-loads the key action ('permanently delete') and resource, making it immediately clear and scannable.

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 highly destructive tool with no annotations and no output schema, the description is incomplete. It doesn't cover success/error responses, side effects on related entities, or safety warnings beyond 'permanently', leaving significant gaps for agent decision-making.

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

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

Schema description coverage is 100%, so the schema fully documents the single parameter (workspace_id as UUID). The description adds no parameter-specific semantics beyond implying the workspace must exist to be deleted, maintaining the 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 action ('permanently delete') and resource ('a workspace and all its data'), distinguishing it from siblings like delete_article or delete_competitor. It specifies the destructive scope beyond just the workspace itself.

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 update_workspace or get_workspace. It doesn't mention prerequisites (e.g., workspace must exist, user permissions) or warn against irreversible consequences beyond stating 'permanently'.

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 'Disable[s] a keyword' which implies a mutation, but doesn't disclose behavioral traits like whether this is reversible, requires specific permissions, affects existing content, or has side effects. The phrase 'exclude it from content suggestions' hints at impact but is vague.

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 purpose, making it easy to parse quickly.

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

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

Given no annotations and no output schema, the description is minimal but covers the basic purpose. For a mutation tool with two parameters, it lacks details on behavior, output, or error handling, making it adequate but with clear gaps in 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 100%, so the schema already documents both parameters (workspace_id and keyword_id as UUIDs). The description adds no additional meaning about parameters beyond what's in the schema, such as where to find these IDs or format details, meeting the baseline for high 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 ('Disable') and resource ('a keyword') with the purpose 'to exclude it from content suggestions.' It distinguishes from siblings like 'enable_keyword' by specifying the opposite action, but doesn't explicitly differentiate from other keyword-related tools like 'delete_keyword' or 'get_keyword' beyond the 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 like 'enable_keyword' or 'delete_keyword.' The description implies it's for excluding keywords from suggestions, but lacks context on prerequisites, timing, or comparisons with 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?

With no annotations, the description carries full burden but provides minimal behavioral insight. It implies a state change (enabling) but doesn't disclose permissions needed, side effects (e.g., if enabling affects existing content), rate limits, or what happens on success/failure. This is inadequate for a mutation tool with zero annotation coverage.

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

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

The description is a single, efficient sentence with no wasted words. It front-loads the core purpose and is appropriately sized for the tool's apparent complexity.

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

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

For a mutation tool with no annotations and no output schema, the description is insufficient. It lacks details on behavioral traits, error conditions, return values, and usage context. Given the sibling 'disable_keyword', more guidance on state management would be beneficial.

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

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

Schema description coverage is 100%, so the schema fully documents both parameters. The description adds no parameter-specific information beyond implying that 'keyword_id' refers to a keyword to enable. This meets the baseline for high schema coverage.

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

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

The description clearly states the action ('enable') and resource ('keyword') with the purpose ('so it can be used for content suggestions'). It distinguishes from sibling 'disable_keyword' by specifying the opposite state, though it doesn't explicitly differentiate from other keyword-related tools like 'create_keyword' or 'get_keyword'.

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., the keyword must exist and be disabled), nor does it specify scenarios where enabling is appropriate versus creating a new keyword or using other keyword tools.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the export action but fails to specify whether this is read-only, requires permissions, affects the original article, or includes rate limits. This leaves significant gaps for a tool that likely involves data access.

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 front-loads the core purpose and includes essential details about formats, 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 moderate complexity (export with format options), no annotations, and no output schema, the description is incomplete. It covers the basic action but lacks details on behavioral traits, output structure, or error handling, which are 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 100%, so the schema fully documents the three parameters (workspace_id, article_id, format). The description adds minimal value by listing the format options but doesn't provide additional context beyond what's in the schema, such as default behavior or format-specific details.

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 ('Export') and resource ('article content'), specifying the output formats (HTML, Markdown, or XML). It distinguishes from siblings like 'get_article' by focusing on format conversion rather than retrieval, though it doesn't explicitly contrast with all 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?

No guidance is provided on when to use this tool versus alternatives like 'get_article' or 'publish_article'. The description lacks context about prerequisites, such as needing an existing article, or exclusions, like not being suitable for editing.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It adds value by stating the tool runs asynchronously and requires checking back for results, which are key behavioral traits not evident from the schema. However, it lacks details on permissions, rate limits, error handling, or what 'shortly' means, leaving gaps 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 highly concise and front-loaded: the first sentence states the core purpose, and the second adds crucial behavioral context (asynchronous nature). Every sentence earns its place with no wasted words, 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 no annotations and no output schema, the description provides basic completeness by covering purpose and asynchronous behavior. However, for a tool with two parameters and no structured output info, it lacks details on result format, error cases, or integration with sibling tools, leaving room for improvement in contextual coverage.

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

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

Schema description coverage is 100%, so the schema fully documents the two parameters (workspace_id and keyword_id). The description adds no additional meaning or context about these parameters beyond what's in the schema, such as how they relate to the generation process. Baseline 3 is appropriate when the schema handles parameter documentation effectively.

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: 'Generate long-tail keyword variations from a primary keyword.' It specifies the verb ('generate'), resource ('long-tail keyword variations'), and input source ('primary keyword'), making the function unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'generate_suggestions' or 'create_keyword', which could have overlapping domains.

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 it 'runs asynchronously' and to 'check back shortly for results,' which suggests when to use it (for asynchronous processing) but doesn't provide explicit guidance on when to choose this tool over alternatives like 'generate_suggestions' or 'create_keyword'. No exclusions or prerequisites are stated.

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

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

With no annotations provided, the description carries full burden but only adds that it 'Runs asynchronously'. It lacks critical behavioral details such as required permissions, rate limits, what 'content suggestions' entail, or how to retrieve results, leaving significant gaps for a tool that likely involves AI processing.

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 concise with two short sentences that are front-loaded with the core action. However, the second sentence about asynchronicity, while useful, could be integrated more seamlessly, and overall it feels slightly sparse given the tool's complexity.

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 a tool that involves AI generation and asynchronicity, the description is incomplete. It fails to explain what 'content suggestions' are, how to access results, error handling, or integration with sibling tools like 'get_suggestion', making it inadequate for informed 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 100%, so the schema fully documents the single parameter 'workspace_id'. The description adds no additional parameter semantics beyond implying it uses 'workspace keywords', which is not a parameter. Baseline 3 is appropriate as the schema handles parameter documentation 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 ('Trigger AI to generate new content suggestions') and the resource ('based on the workspace keywords'), making the purpose understandable. However, it doesn't explicitly differentiate from sibling tools like 'generate_long_tail_keywords' or 'get_suggestion', which reduces 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 minimal guidance by mentioning it 'Runs asynchronously', but offers no explicit when-to-use context, prerequisites, or alternatives. It doesn't clarify when to choose this over similar tools like 'generate_long_tail_keywords' or 'get_suggestion', leaving usage ambiguous.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions that the response includes specific fields like HTML content when status is 'done', which adds some context about output behavior. However, it lacks critical details such as whether this is a read-only operation, error handling for invalid IDs, or authentication requirements, leaving significant gaps for a tool that fetches data.

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

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

The description is concise and front-loaded, with the core purpose stated in the first sentence and additional details in the second. Both sentences earn their place by clarifying the action and output conditions, though it could be slightly more structured by explicitly separating purpose from behavioral 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 the lack of annotations and output schema, the description is incomplete for a data retrieval tool. It hints at output content but doesn't fully specify the return structure, error cases, or side effects. For a tool with two required parameters and no structured output documentation, more comprehensive guidance is needed to ensure reliable agent usage.

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

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

The input schema has 100% description coverage, with clear documentation for both parameters (workspace_id and article_id as UUIDs). The description doesn't add any semantic details beyond what the schema provides, such as explaining the relationship between workspace and article or parameter constraints. This meets the baseline score since the schema adequately covers 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 clearly states the action ('Get full details') and resource ('an article'), making the purpose immediately understandable. However, it doesn't explicitly differentiate this tool from sibling tools like 'list_articles' or 'export_article', which would require more specific language about what makes this retrieval unique beyond the basic operation.

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 article ID, or contrast it with similar tools like 'list_articles' for browsing or 'export_article' for different output formats, leaving the agent 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 of behavioral disclosure. It states the tool retrieves details but does not cover critical aspects like whether it's a read-only operation, authentication requirements, error handling, rate limits, or response format. 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 action ('Get full details of a briefing') and lists key attributes without unnecessary words. It is appropriately sized and wastes no space, making it easy for an agent to parse quickly.

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

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

Given the lack of annotations and output schema, the description is incomplete. It specifies what details are retrieved but omits behavioral traits, error conditions, and response structure. For a tool with no structured metadata, this leaves the agent under-informed about how to handle the 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?

The input schema has 100% description coverage, with clear documentation for 'workspace_id' and 'briefing_id' as UUIDs. The description does not add any parameter-specific information beyond what the schema provides, such as format examples or contextual usage, so it meets the baseline for high schema coverage without extra value.

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: 'Get full details of a briefing' with specific attributes listed (topic, title, type, length, focus keywords, instructions). It uses a specific verb ('Get') and resource ('briefing'), but does not explicitly differentiate from sibling tools like 'list_briefings' or 'get_article', which slightly limits its clarity.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention sibling tools like 'list_briefings' (for listing briefings) or 'get_article' (for getting article details), nor does it specify prerequisites or contexts for usage, leaving the agent without explicit 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?

No annotations are provided, so the description carries full burden. It mentions 'connection status' which hints at behavioral output, but doesn't disclose critical details like authentication requirements, rate limits, error responses, whether it's idempotent, or what happens if the integration doesn't exist. For a read operation with zero annotation coverage, this leaves 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?

Single sentence efficiently conveys the core purpose without unnecessary words. However, it could be more front-loaded by starting with 'Retrieve' instead of 'Get' for slightly better clarity, and lacks structural elements like bullet points for the included details.

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

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

For a simple read operation with 2 parameters and 100% schema coverage, the description is minimally adequate but incomplete. Without annotations or output schema, it should ideally mention response format, error cases, or authentication needs. The mention of 'service-specific fields and connection status' adds some value but doesn't fully compensate for missing 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?

Schema description coverage is 100%, so the schema already documents both parameters (workspace_id and integration_id as UUIDs). The description doesn't add any parameter-specific information beyond what's in the schema, such as format examples or relationship between parameters. Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description clearly states the verb 'Get' and resource 'full details of an integration', specifying it includes 'service-specific fields and connection status'. This distinguishes it from list_integrations (which likely returns summaries) but doesn't explicitly differentiate from get_workspace or other get_* tools that retrieve different resources.

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 list_integrations or get_workspace. The description implies it's for retrieving detailed integration data but doesn't specify prerequisites, error conditions, or comparative use cases with 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 indicates this is a read operation ('Get'), but does not specify whether it requires authentication, has rate limits, returns paginated results, or handles errors. For a tool with zero annotation coverage, this leaves significant gaps in understanding its behavior beyond the basic purpose.

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 key details without unnecessary words. It avoids redundancy and wastes no space, making it easy for an agent to parse quickly.

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

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

Given the tool's complexity (a simple read operation with 2 parameters), no annotations, and no output schema, the description is minimally adequate. It covers what the tool does but lacks behavioral context, usage guidelines, and output details. This leaves the agent with gaps, especially since there is no output schema to clarify return values, making it incomplete for optimal 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 input schema has 100% description coverage, with clear documentation for both parameters ('workspace_id' and 'keyword_id'). The description does not add any semantic details beyond what the schema provides (e.g., it does not explain how to obtain these IDs or their format). With high schema coverage, the baseline score of 3 is appropriate, as the description does not compensate but also does not detract.

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: 'Get full details of a keyword including search volume, competition, CPC, and search intent.' It specifies the verb ('Get') and resource ('keyword'), and lists the types of details returned. However, it does not explicitly differentiate from sibling tools like 'list_keywords' or 'get_suggestion', which would require a more specific distinction to achieve a score of 5.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites (e.g., needing a specific keyword ID), exclusions, or comparisons to sibling tools such as 'list_keywords' (for listing multiple keywords) or 'get_suggestion' (for keyword suggestions). Without such context, the agent lacks clear usage instructions.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. While 'Get' implies a read operation, it doesn't specify whether this requires specific permissions, what happens if the workspace doesn't exist, whether it returns all settings or a subset, or any rate limits. The description lists example setting types but doesn't clarify if this is exhaustive or representative.

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 immediately states the purpose with concrete examples. Every word contributes value - no redundant phrases or unnecessary elaboration. 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?

For a simple read operation with 100% schema coverage but no annotations or output schema, the description is minimally adequate. It specifies what's being retrieved but lacks behavioral context about permissions, error conditions, or return format. The complexity is low (single parameter, read-only), so the description meets basic requirements but could be more complete.

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

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

Schema description coverage is 100% with the single parameter 'workspace_id' well-documented in the schema. The description doesn't add any parameter-specific information beyond what's in the schema. According to guidelines, when schema coverage is high (>80%), the baseline is 3 even with no param info in description.

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

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

The description clearly states the verb ('Get') and resource ('workspace settings') with specific examples of what settings are included (language, article length, pictures style, writing preferences, content limits). It distinguishes from sibling tools like 'get_workspace' or 'list_workspaces' by focusing on settings rather than workspace metadata. However, it doesn't explicitly differentiate from 'update_settings' beyond the verb difference.

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 authentication, whether it's for current workspace or any workspace, or when you'd use 'get_workspace' versus 'get_settings'. No explicit when/when-not statements or alternative tool references are provided.

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

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

No annotations are provided, so the description carries full burden for behavioral disclosure. It implies a read-only operation ('Get'), but doesn't state whether it requires authentication, has rate limits, returns errors for invalid IDs, or if the data is cached. For a tool with no annotation coverage, this leaves significant gaps in understanding its behavior and constraints.

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 full details of a suggestion') and lists key attributes without redundancy. Every word earns its place, making it easy to parse and understand quickly. No structural issues or wasted verbiage are present.

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 (2 required parameters, no output schema, no annotations), the description is minimally adequate. It states the purpose and output attributes, but lacks behavioral context (e.g., error handling) and usage guidelines. For a read operation, this might suffice, but the absence of annotations and output schema means the description could do more to compensate (e.g., hinting at return structure).

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

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

Schema description coverage is 100%, with both parameters (workspace_id, suggestion_id) clearly documented as UUIDs in the schema. The description adds no parameter-specific information beyond implying these IDs are needed to fetch details. This meets the baseline of 3 when the schema does the heavy lifting, but doesn't enhance understanding (e.g., explaining where to obtain these IDs).

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: 'Get full details of a suggestion' with a specific list of attributes (topic, title, type, length, language, focus keywords, description). It distinguishes from siblings like 'list_suggestions' (which likely returns summaries) and 'accept_suggestion'/'reject_suggestion' (which modify suggestions). However, it doesn't explicitly contrast with 'get_article' or other 'get_' tools, keeping it at 4 rather than 5.

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

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 suggestion ID from 'list_suggestions'), contrast with 'list_suggestions' for summaries versus details, or specify use cases like reviewing suggestion metadata before acceptance/rejection. Without such context, the agent must infer usage from the name and sibling tools 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 it's a read operation ('Get details'), but doesn't disclose behavioral aspects like error handling, authentication needs, rate limits, or what happens if the tone_id is invalid. The description is minimal and lacks 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 a single, efficient sentence that front-loads the core purpose. Every word contributes to understanding the tool's function 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 simplicity (1 parameter, no output schema, no annotations), the description is adequate but minimal. It covers the basic purpose but lacks details on usage context, behavioral traits, or output format, which could be helpful for 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 100%, with the single parameter 'tone_id' documented as 'Tone of voice UUID'. The description adds no additional parameter semantics beyond what the schema provides, so it meets the baseline for high 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 the resource 'details of a specific tone of voice', specifying what information is retrieved (name, code, description). It distinguishes from sibling 'list_tones' by focusing on a single tone, but 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 is provided on when to use this tool versus alternatives like 'list_tones' or other get_* tools. The description implies usage for retrieving details of a known tone, but lacks explicit context or prerequisites.

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 indicates this is a read operation ('Get'), which implies non-destructive behavior, but does not disclose other traits like authentication needs, rate limits, or error handling. The description adds value by specifying the scope of details returned, but lacks comprehensive behavioral context.

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

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

The description is a single, efficient sentence that front-loads the core action ('Get full details') and lists specific attributes without unnecessary words. Every part of the sentence adds value by clarifying what details are included, 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 tool's low complexity (1 parameter, no nested objects, no output schema) and lack of annotations, the description is fairly complete for a read operation. It specifies the resource and details returned, but could improve by mentioning output format or error cases. However, it adequately covers the core functionality without being overly verbose.

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

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

The input schema has 100% description coverage, with the single parameter 'workspace_id' documented as 'Workspace UUID'. The description does not add any meaning beyond this, as it does not explain parameter usage or constraints. With high schema coverage, the baseline score of 3 is appropriate, as the schema handles parameter documentation 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 verb 'Get' and the resource 'workspace', specifying it retrieves 'full details' and listing specific attributes like name, domain, status, etc. It distinguishes from sibling tools like 'list_workspaces' (which likely lists multiple workspaces) and 'update_workspace' (which modifies a workspace), making the purpose specific and differentiated.

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

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

The description implies usage when needing detailed workspace information, but does not explicitly state when to use this tool versus alternatives like 'list_workspaces' or 'update_workspace'. No exclusions or prerequisites are mentioned, leaving usage context somewhat implied rather than clearly defined.

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 filtering capabilities but doesn't disclose behavioral traits like whether this is a read-only operation, pagination behavior (implied by parameters but not described), rate limits, authentication needs, or what happens if filters return no results. For a list tool with 5 parameters and no annotations, this leaves 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 a single, efficient sentence that front-loads the core purpose ('List articles for a workspace') and adds useful filtering details. There's no wasted text, and it's appropriately sized for the tool's complexity.

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

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

Given no annotations and no output schema, the description is incomplete for a tool with 5 parameters. It doesn't explain return values, error conditions, pagination behavior, or authentication requirements. For a list tool that likely returns structured data, this leaves the agent with insufficient context to use it effectively beyond basic parameter passing.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds marginal value by mentioning filtering by status or published state, which aligns with the schema but doesn't provide additional semantic context beyond what's in the parameter descriptions. Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description clearly states the verb 'List' and resource 'articles for a workspace', which is specific and actionable. It distinguishes from siblings like 'get_article' (singular) and 'export_article', but doesn't explicitly differentiate from other list tools like 'list_briefings' or 'list_workspaces' beyond the resource type.

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

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

The description implies usage context by mentioning filtering by status or published state, suggesting this tool is for retrieving filtered article lists. However, it doesn't provide explicit guidance on when to use this versus alternatives like 'get_article' for single articles or other list tools for different resources, nor does it mention 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 mentions filtering by status but doesn't disclose other behavioral traits like pagination behavior (implied by page/per_page parameters but not described), rate limits, authentication needs, error conditions, or what happens when no briefings match. The description is minimal beyond basic functionality.

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 includes essential filtering information. Every word earns its place with zero waste or redundancy.

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

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

For a list operation with 4 parameters, 100% schema coverage, and no output schema, the description is adequate but minimal. It covers the basic purpose and filtering but lacks behavioral context about pagination, response format, or error handling. Without annotations, more completeness would be beneficial for safe agent operation.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds marginal value by mentioning the status filter options, but doesn't provide additional semantic context beyond what's in the schema. With high schema coverage, baseline 3 is appropriate.

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 briefings') and resource ('for a workspace'), with additional clarification about what briefings are ('direct article writing instructions'). It distinguishes the tool from other list_* siblings by specifying the resource type, but doesn't explicitly differentiate from get_briefing (singular vs. plural).

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 workspace filtering and status options, but doesn't explicitly state when to use this tool versus alternatives like get_briefing (singular) or other list_* tools. No guidance is provided about prerequisites, timing, or exclusion criteria.

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 lists competitor domains but doesn't disclose behavioral traits like pagination behavior (implied by 'page' and 'per_page' parameters), rate limits, authentication needs, error conditions, or what 'analyzed' entails. 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 concise with two sentences that are front-loaded: the first states the core function, and the second adds purpose. There's no wasted text, but it could be more structured (e.g., separating usage notes). It efficiently communicates the essentials without verbosity.

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

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

Given no annotations and no output schema, the description is incomplete for a tool with three parameters and list functionality. It lacks details on return values (e.g., format of competitor domains), pagination behavior, error handling, and operational constraints. For a read operation with potential complexity, more context is needed to guide effective use.

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

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

Schema description coverage is 100%, so the schema fully documents parameters (workspace_id, page, per_page). The description adds no additional meaning beyond what's in the schema—it doesn't explain parameter relationships, default values, or usage context. Baseline 3 is appropriate as the schema handles parameter documentation 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 ('List competitor domains') and resource ('for a workspace'), with the purpose 'to inform content strategy' adding context. It distinguishes from siblings like 'create_competitor' or 'delete_competitor' by focusing on listing, but doesn't explicitly differentiate from other list tools (e.g., 'list_articles').

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 an existing workspace), exclusions, or comparisons to similar tools like 'list_workspaces' or 'get_competitor' (if it existed). The description implies usage for content strategy but lacks explicit when/when-not instructions.

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 'Integrations connect to WordPress, Webflow, Wix, GoHighLevel, or Webhook endpoints,' which adds context about integration types. However, it lacks critical behavioral details: whether this is a read-only operation, pagination behavior (implied by page/per_page params but not explained), rate limits, authentication needs, or what the output looks like (no output schema).

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

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

The description is two sentences, front-loaded with the core purpose. The first sentence states the tool's function clearly, and the second adds useful context about integration types. There's no wasted verbiage, though it could be slightly more structured (e.g., bullet points for integration types).

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

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

Given no annotations and no output schema, the description is moderately complete. It covers the what (list integrations) and examples of integration types, but lacks behavioral transparency (safety, pagination, auth) and output details. For a list tool with 3 parameters and 100% schema coverage, it's adequate but has clear gaps in usage and 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?

Schema description coverage is 100%, so the schema already documents all three parameters (workspace_id, page, per_page) with descriptions. The description adds no parameter-specific semantics beyond what the schema provides. It mentions 'workspace' generally but doesn't clarify parameter usage or constraints. Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description clearly states the tool's purpose: 'List publishing integrations for a workspace' specifies the verb (list) and resource (publishing integrations). It distinguishes from siblings like 'get_integration' (singular) and 'create_integration' (write operation). However, it doesn't explicitly differentiate from other list tools (e.g., list_articles) beyond the resource type.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., workspace access), when not to use it, or compare it to siblings like 'get_integration' (for single integration details) or 'create_integration' (for adding new integrations). 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 that 'Keywords drive content suggestions,' adding some context about the resource's role, but lacks critical behavioral details: it doesn't specify if this is a read-only operation, whether it requires authentication, if there are rate limits, pagination behavior beyond parameters, or what the output format looks like (e.g., list of objects). For a tool with 6 parameters and no annotations, 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 concise with two sentences: the first states the core purpose, and the second adds filtering details. It's front-loaded with the main action and avoids unnecessary words. However, it could be slightly more structured by explicitly separating filtering options or adding a brief note on output.

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 (6 parameters, no output schema, no annotations), the description is incomplete. It doesn't explain the return values (e.g., what fields are included in keyword objects), pagination behavior beyond parameters, error conditions, or authentication requirements. For a list tool with filtering and pagination, this leaves significant gaps for an AI agent to use it correctly.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly (e.g., 'workspace_id' as UUID, 'level' with values 1 or 2). The description adds minimal value by mentioning filtering by level and status, but doesn't provide additional semantics beyond what's in the schema. With high schema coverage, the baseline score of 3 is appropriate.

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 ('keywords for a workspace'), making the purpose specific and understandable. It distinguishes from some siblings like 'create_keyword' or 'delete_keyword' by indicating retrieval rather than mutation, but doesn't explicitly differentiate from other list tools like 'list_articles' or 'list_workspaces' beyond the resource type.

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

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

The description implies usage through the mention of filtering capabilities ('Filter by level or status'), suggesting when this tool might be preferred over a simpler list operation. However, it doesn't provide explicit guidance on when to use this versus alternatives like 'get_keyword' (for single keyword) or other list tools, nor does it mention 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states this is a listing operation, implying it's likely read-only, but doesn't explicitly confirm this. It mentions that Balzac uses these links for articles, which adds some context about the tool's role in the system, but fails to describe important behaviors like pagination handling (despite page/per_page parameters), rate limits, authentication requirements, 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 appropriately concise with two sentences. The first sentence directly states the tool's purpose, and the second adds useful context about how the links are used in the system. There's no wasted verbiage or redundancy. However, it could be slightly more front-loaded by incorporating the Balzac context into the main purpose 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?

For a listing tool with 3 parameters and no output schema, the description provides adequate basic purpose but lacks important context. It doesn't explain the return format, pagination behavior, or any constraints on usage. The mention of Balzac's use of links adds some system context, but doesn't compensate for the missing behavioral information that would help an agent use the 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 100%, so the schema already documents all three parameters (workspace_id, page, per_page) with basic descriptions. The description adds no additional parameter semantics beyond what's in the schema - it doesn't explain format expectations for workspace_id, default values for page/per_page, or how pagination works. The baseline of 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the action ('List reference links') and target resource ('for a workspace'), providing a specific verb+resource combination. It distinguishes the tool's purpose from siblings like 'create_link' or 'delete_link' by focusing on listing rather than creating/deleting. However, it doesn't explicitly differentiate from other list_* tools (like list_articles, list_keywords) beyond mentioning that Balzac uses these links for articles.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when to use list_links versus other listing tools (like list_articles), nor does it specify any prerequisites or constraints beyond the required workspace_id parameter. The mention of Balzac weaving links into articles is contextual but doesn't translate into actionable usage 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 full burden. It describes the tool as a list operation with filtering, which implies read-only behavior, but doesn't disclose critical behavioral traits such as pagination handling (implied by page/per_page parameters but not explained), rate limits, authentication needs, or what the output looks like (e.g., format, fields). This leaves significant gaps for an agent to use it correctly.

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 concise and front-loaded with the core purpose in the first sentence, followed by filtering details. Both sentences earn their place by clarifying the resource type and usage. It could be slightly more structured by explicitly mentioning pagination, but overall it's efficient with zero waste.

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

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

Given no annotations and no output schema, the description is incomplete for a tool with 4 parameters and list functionality. It lacks details on behavioral aspects (e.g., pagination, rate limits), output format, and explicit usage guidelines compared to siblings. For a read operation with filtering and pagination, more context is needed to ensure an agent can invoke it correctly without guesswork.

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

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

Schema description coverage is 100%, so the schema already documents all parameters (workspace_id, status, page, per_page). The description adds minimal value beyond the schema by mentioning that suggestions are 'AI-generated article ideas based on keywords' and that status can be 'proposed, accepted, rejected', but doesn't provide additional syntax, format details, or constraints. Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description clearly states the tool's purpose: 'List content suggestions for a workspace' with the specific resource (content suggestions) and scope (workspace). It distinguishes from siblings like 'get_suggestion' (singular) and 'generate_suggestions' (creation), but doesn't explicitly differentiate from other list tools like 'list_articles' beyond the resource type.

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

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

The description implies usage context by mentioning filtering by status (proposed, accepted, rejected), which suggests when to use this tool for filtered retrieval. However, it doesn't provide explicit guidance on when to use this versus alternatives like 'get_suggestion' for a single suggestion or 'generate_suggestions' for creating new ones, nor does it mention prerequisites or exclusions.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the action ('List') but fails to describe key behaviors like response format, pagination, error handling, or authentication needs. This leaves significant gaps for a tool with no structured behavioral hints.

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

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

The description is a single, efficient sentence that directly states the tool's function without redundancy or fluff. It is front-loaded with the core action and resource, 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 minimally adequate but lacks depth. It explains what the tool does but omits behavioral details like return format or error conditions, which are important for full contextual understanding 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 appropriately does not discuss parameters, maintaining focus on the tool's purpose without unnecessary details, 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 verb ('List') and resource ('all available tones of voice'), specifying their application to 'workspaces and articles'. However, it does not explicitly differentiate from sibling tools like 'get_tone', which likely retrieves a single tone, leaving some ambiguity in sibling distinction.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as 'get_tone' for retrieving a specific tone. It lacks context on prerequisites, timing, or exclusions, offering only a basic functional statement without usage instructions.

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 return fields (id, name, domain, status, language), which adds some behavioral context, but doesn't disclose pagination behavior (implied by parameters but not described), rate limits, authentication needs, or error handling. For a list tool with no annotations, this is a significant gap.

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

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

The description is two concise sentences: one states the purpose, and the other specifies return fields. It's front-loaded with the core action and wastes no words, making it highly efficient.

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

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

Given no annotations, no output schema, and 100% schema coverage, the description is minimally adequate. It covers the basic purpose and return fields, but lacks details on pagination behavior, error cases, or usage context. For a simple list tool, it's functional but could be more complete.

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

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

Schema description coverage is 100%, so the schema already documents all parameters (status, page, per_page) with descriptions. The description doesn't add any parameter-specific details beyond what's in the schema, such as explaining filter logic or default values. Baseline 3 is appropriate when the schema handles parameter 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 ('all workspaces in your Balzac account'), and distinguishes it from siblings like 'get_workspace' (singular) by specifying it returns multiple workspaces with specific fields. It's specific and unambiguous.

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

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

The description implies usage for retrieving multiple workspaces, but doesn't explicitly state when to use this vs. alternatives like 'get_workspace' (for a single workspace) or other list tools (e.g., 'list_articles'). It provides basic context but lacks explicit guidance on 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?

No annotations are provided, so the description carries full burden. It mentions publishing to integrations but lacks details on permissions required, whether it's idempotent, error handling, or what happens post-publication (e.g., article status changes). This is a mutation tool with 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?

Single sentence, front-loaded with the core action, efficiently lists integrations without fluff. Every word serves a purpose, making it easy to scan and understand quickly.

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

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

For a mutation tool with no annotations and no output schema, the description is incomplete. It doesn't cover behavioral aspects like side effects, success indicators, or error cases. Given the complexity of publishing to multiple platforms, more context is needed 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 100%, so the schema documents all parameters (workspace_id, article_id, integration_id). The description adds minimal value by implying these IDs are needed for publishing but doesn't explain relationships (e.g., integration_id must match a connected platform). Baseline 3 is appropriate as the schema does the heavy lifting.

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

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

The description clearly states the action ('publish') and resource ('article'), specifying the target integrations. It distinguishes from siblings like 'schedule_article' or 'update_article' by focusing on publication to external platforms. However, it doesn't explicitly differentiate from 'export_article', which might have overlapping functionality.

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 'export_article' or 'schedule_article'. The description mentions integrations but doesn't specify prerequisites (e.g., needing a connected integration) or exclusions (e.g., not for internal drafts).

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It adds useful context: the status changes to 'pending' during testing, indicating an asynchronous operation with a state transition. However, it lacks details on permissions, rate limits, error handling, or what happens after completion (e.g., success/failure outcomes). The description doesn't contradict annotations, as none exist.

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

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

The description is two concise sentences with zero wasted words. The first sentence states the core action, and the second adds critical behavioral context (status change). It is front-loaded and efficiently structured, making it 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 no annotations and no output schema, the description provides minimal but adequate context for a simple tool with two parameters. It explains the action and a key behavioral trait (status change), but lacks details on return values, error cases, or integration with sibling tools. For a reconnection operation, more completeness would include expected outcomes or failure modes.

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

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

Schema description coverage is 100%, so the schema fully documents the two required parameters (workspace_id and integration_id as UUIDs). The description adds no parameter-specific information beyond what the schema provides, such as where to find these IDs or format details. This meets the baseline for high schema coverage.

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

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

The description clearly states the action ('Re-test the connection') and resource ('an integration'), making the purpose unambiguous. It distinguishes from siblings like 'create_integration' or 'delete_integration' by focusing on connection testing rather than lifecycle management. However, it doesn't explicitly differentiate from 'get_integration' or 'update_integration' in terms of connection-specific operations.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., an existing integration needing reconnection), exclusions, or comparisons to siblings like 'get_integration' (for status checks) or 'update_integration' (for configuration changes). Usage is implied only by the action described.

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

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

With no annotations provided, the description carries the full burden. It discloses key behavioral traits: it's a mutation (implied by 'Regenerate'), has a cost ('Costs 1 credit'), and runs asynchronously. However, it doesn't cover other important aspects like permissions needed, error handling, or what 'asynchronously' entails (e.g., how to check status), which are gaps for a tool with no annotations.

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

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

The description is extremely concise and front-loaded, consisting of just two sentences that efficiently convey the core action, cost, and execution mode. Every word earns its place, with no wasted information, making it highly effective in 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 the complexity (a mutation tool with cost and async behavior), no annotations, and no output schema, the description is somewhat complete but has gaps. It covers the basic action and key behaviors but lacks details on permissions, error cases, or how to handle the async result, which are important for a tool of this nature. It's adequate but not fully comprehensive.

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

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

The schema description coverage is 100%, so the schema already documents all parameters well. The description adds no additional meaning about the parameters beyond what the schema provides (e.g., it doesn't explain the purpose of 'pictures_style' or 'additional_instructions' further). Thus, it meets the baseline of 3 without compensating or adding value.

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 ('Regenerate') and resource ('main picture of an article'), making the purpose specific and understandable. However, it doesn't explicitly differentiate from sibling tools like 'update_article' or 'rewrite_article', which might also involve article modifications, so it doesn't reach the highest score.

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

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

The description implies usage by mentioning it 'Runs asynchronously' and 'Costs 1 credit', which provides some context for when to use it (e.g., for non-immediate results with a cost). However, it lacks explicit guidance on when to choose this over alternatives like 'update_article' or other article-related tools, leaving room for ambiguity.

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 action ('Reject') and outcome ('not be used for article writing'), but lacks details on permissions, reversibility, side effects, or response format. For a mutation tool with zero annotation coverage, 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 concise with two sentences that are front-loaded and to the point. However, the second sentence could be integrated more smoothly, and there's room for slight improvement in flow.

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

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

Given this is a mutation tool with no annotations, no output schema, and incomplete behavioral disclosure, the description is inadequate. It should cover more about the tool's effects, error conditions, or integration with sibling tools like 'accept_suggestion'.

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

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

Schema description coverage is 100%, so the schema already documents both parameters (workspace_id and suggestion_id). The description doesn't add any meaning beyond what the schema provides, such as explaining how to obtain these IDs or their relationships.

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 ('Reject a suggestion') and the outcome ('It will not be used for article writing'), which distinguishes it from the sibling 'accept_suggestion'. However, it doesn't specify what type of suggestion (e.g., content, keyword) or resource context, keeping it from a perfect score.

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

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

No explicit guidance is provided on when to use this tool versus alternatives like 'accept_suggestion' or 'delete_suggestion' (if it existed). The description implies usage for article writing suggestions but lacks context on 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It adds valuable context: the operation costs 3 credits and runs asynchronously, which are critical behavioral traits not inferable from the schema. However, it doesn't disclose permissions needed, whether the rewrite is destructive to the original article, rate limits, or what the asynchronous response looks like (e.g., job ID, polling mechanism).

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 with zero waste. The first sentence states the core purpose, the second adds critical behavioral context (cost and async nature). Every word earns its place, and the most important information is front-loaded.

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

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

Given a mutation tool with no annotations and no output schema, the description is incomplete. It covers the basic operation and two key behavioral aspects (cost and async), but misses important context: what permissions are required, whether the rewrite overwrites the original article or creates a new version, how to track the async job, error conditions, and typical response format. For a 6-parameter tool that modifies content, this leaves significant gaps for the agent.

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

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

Schema description coverage is 100%, so the schema already documents all six parameters thoroughly. The description adds no parameter-specific semantics beyond implying that parameters are optional (except workspace_id and article_id). It doesn't explain interactions between parameters (e.g., how 'additional_instructions' combines with 'tone_of_voice_id') or provide examples. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the tool's purpose: 'Rewrite an existing article with optional new parameters.' It specifies the verb (rewrite) and resource (article), and distinguishes it from siblings like 'update_article' by focusing on content transformation rather than metadata updates. However, it doesn't explicitly differentiate from 'regenerate_article_picture' or other content-modification 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 'update_article' or 'regenerate_article_picture'. It mentions it runs asynchronously and costs credits, but doesn't specify prerequisites, error conditions, or typical use cases. The agent must infer usage from the tool name and parameter set alone.

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

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

No annotations are provided, so the description carries the full burden. It states the tool schedules for 'future publication,' implying a mutation (write operation), but doesn't disclose behavioral traits such as required permissions, whether scheduling is reversible, rate limits, or what happens on success/failure. This is a significant gap for a mutation tool.

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

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

The description is a single, efficient sentence with zero waste. It's 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 complexity (a mutation with 4 required parameters), lack of annotations, and no output schema, the description is incomplete. It doesn't cover behavioral aspects like permissions, side effects, or error handling, leaving gaps that could hinder correct agent usage.

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

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

Schema description coverage is 100%, so the schema fully documents all four parameters (workspace_id, article_id, integration_id, scheduled_for). The description adds no additional meaning beyond implying these parameters are needed for scheduling, matching the baseline score when schema does the heavy lifting.

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

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

The description clearly states the action ('schedule') and resource ('article'), specifying it's for 'future publication on a connected integration.' This distinguishes it from tools like 'publish_article' (immediate) and 'update_article' (modify). However, it doesn't explicitly differentiate from all siblings (e.g., 'export_article' also involves articles).

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 an existing article and integration), exclusions, or comparisons to siblings like 'publish_article' (immediate) or 'update_article' (which might handle scheduling differently).

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. While 'Update' implies a mutation operation, the description doesn't specify whether this requires specific permissions, whether changes are reversible, what happens to existing metadata not mentioned, or what the response looks like. For a mutation tool with zero annotation coverage, this is a significant gap.

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

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

The description is a single, efficient sentence that front-loads the core purpose and enumerates the updatable fields. There's zero wasted language or redundancy, making it maximally concise while still conveying essential information.

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

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

For a mutation tool with 7 parameters, no annotations, and no output schema, the description is insufficient. It doesn't address behavioral aspects like permissions, side effects, error conditions, or response format. While the schema covers parameter documentation, the overall context for safe and effective tool use is incomplete.

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

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

Schema description coverage is 100%, so the schema already documents all 7 parameters thoroughly. The description lists the updatable fields (title, slug, description, language, tone of voice) which aligns with 5 of the 7 parameters, but doesn't add meaningful semantic context beyond what the schema already provides. Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description clearly states the verb ('Update') and resource ('article metadata'), and specifies which fields can be updated (title, slug, description, language, tone of voice). It doesn't explicitly differentiate from sibling tools like 'rewrite_article' or 'publish_article', but the focus on metadata updates provides reasonable 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 'rewrite_article' (which might update content rather than metadata) or 'publish_article' (which might change publication status). There's no mention of prerequisites, constraints, or typical use cases for metadata 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 provided, the description carries full burden. It discloses that the tool performs an update operation (implying mutation) and that 'A connection test runs automatically after update', which is valuable behavioral context. However, it lacks details on permissions required, whether changes are reversible, error handling, or what happens to unspecified fields. For a mutation tool with 22 parameters and no annotations, this is a moderate gap.

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

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

The description is two sentences with zero waste. The first sentence clearly states the purpose and scope, and the second sentence adds important behavioral context about the automatic connection test. Every word earns its place, and information is front-loaded appropriately.

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 (22 parameters, mutation operation) and lack of both annotations and output schema, the description is moderately complete. It covers the basic purpose and one behavioral trait, but doesn't address permissions, error handling, response format, or detailed usage scenarios. For a tool with this many parameters and no structured output information, more context would be beneficial.

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

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

Schema description coverage is 100%, so the schema fully documents all 22 parameters. The description adds minimal value beyond the schema by listing 'name, auto_publish, and service-specific credentials' as updatable fields, but doesn't provide additional syntax, format, or interaction details. This meets the baseline of 3 when schema coverage is high.

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 ('an integration'), and specifies what can be changed ('name, auto_publish, and service-specific credentials'). It distinguishes from siblings like 'create_integration' and 'delete_integration' by focusing on modification rather than creation or deletion. However, it doesn't explicitly differentiate from 'reconnect_integration' which might have overlapping functionality.

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

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

The description implies usage when updating integration settings, but provides no explicit guidance on when to use this tool versus alternatives like 'reconnect_integration' or 'create_integration'. It mentions an automatic connection test, which hints at post-update validation, but doesn't specify prerequisites, error conditions, or when not to use it.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. While 'Update' implies a mutation operation, the description doesn't address critical behavioral aspects: whether this requires specific permissions, if changes are reversible, what happens to unspecified settings, potential side effects, or error conditions. For a mutation tool with 11 parameters and no annotation coverage, this is a significant gap.

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

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

The description is a single, efficient sentence that front-loads the core purpose ('Update workspace settings') followed by illustrative examples. There's no wasted verbiage, though the 'and more' could be slightly more precise. The structure is clear and direct.

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

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

Given the tool's complexity (mutation operation with 11 parameters), lack of annotations, and absence of an output schema, the description is minimally adequate but incomplete. It identifies the tool's purpose and some example parameters but omits behavioral context, usage guidance, and output expectations. For a settings mutation tool, more comprehensive disclosure would be beneficial.

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

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

Schema description coverage is 100%, so the schema already documents all 11 parameters thoroughly. The description lists some example parameters (language, article length, pictures style, tone, auto-accept suggestions, writing style preferences) but adds no additional semantic context beyond what's in the schema. This meets the baseline of 3 when schema coverage is high.

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: 'Update workspace settings' followed by a non-exhaustive list of specific settings that can be modified (language, article length, pictures style, tone, auto-accept suggestions, writing style preferences). It uses a specific verb ('Update') and identifies the resource ('workspace settings'), though it doesn't explicitly differentiate from the sibling 'update_workspace' tool.

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 the sibling 'update_workspace' tool, nor does it indicate prerequisites, constraints, or appropriate contexts for use. The agent must infer usage from the tool name and description alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states this is an update operation, implying mutation, but doesn't cover critical aspects like required permissions, whether changes are reversible, error conditions, or response format. For a mutation tool with zero annotation coverage, this leaves significant gaps in understanding how the tool 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 a single, efficient sentence that front-loads the key information (update action and fields). There is no wasted verbiage or redundancy, 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 7 parameters, no annotations, and no output schema, the description is insufficient. It doesn't explain the mutation's impact, error handling, or what happens to unspecified fields. Given the complexity and lack of structured support, more behavioral and usage context is needed for the agent 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?

The description lists the updatable fields (name, description, language, pictures style, article limits), which aligns with 6 of the 7 parameters in the schema. With 100% schema description coverage, the schema already documents all parameters thoroughly. The description adds minimal value beyond what's in the schema, meeting the baseline for high 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 ('Update') and resource ('workspace'), and specifies the fields that can be modified (name, description, language, pictures style, article limits). It distinguishes from siblings like 'create_workspace' and 'delete_workspace' by focusing on modification rather than creation or deletion. However, it doesn't explicitly differentiate from other update tools like 'update_article' or 'update_integration' beyond the workspace focus.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing workspace), exclusions, or comparisons to sibling tools like 'update_settings' or 'get_workspace'. 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.