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 'Get feedback/conversation logs,' implying a read-only operation, but doesn't specify if this requires special permissions, the format of the logs (e.g., structured vs. raw), pagination, rate limits, or error conditions. For a tool with no annotations, this leaves significant gaps in understanding its behavior.

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

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

The description is a single, clear sentence: 'Get feedback/conversation logs for a WhatsApp AI agent.' It's front-loaded with the core purpose, uses efficient language, and avoids unnecessary words. Every part of the sentence contributes directly to understanding the tool's function, making it highly concise and well-structured.

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

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

Given the complexity (a tool for retrieving logs/feedback), lack of annotations, and no output schema, the description is incomplete. It doesn't explain what 'feedback/conversation logs' entail (e.g., format, content, time range), how results are returned, or any prerequisites. For a tool that likely returns detailed data, this leaves too much unspecified, making it inadequate for reliable agent use.

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

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

The input schema has 100% description coverage, with one required parameter 'id' described as 'AI Agent ID (UUID).' The description doesn't add any extra semantic details beyond this, such as where to find the ID or if it's case-sensitive. Given the high schema coverage, a baseline score of 3 is appropriate, as the schema adequately documents the parameter without needing additional explanation in the description.

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

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

The description clearly states the tool's purpose: 'Get feedback/conversation logs for a WhatsApp AI agent.' It specifies the action ('Get'), resource ('feedback/conversation logs'), and context ('WhatsApp AI agent'), which is specific and actionable. However, it doesn't explicitly differentiate from sibling tools like 'manycontacts_ai_agents_get' or 'manycontacts_messages_list', which might overlap in retrieving agent-related data, preventing a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. For example, it doesn't clarify if this is for historical logs, real-time feedback, or how it differs from 'manycontacts_ai_agents_get' (which might retrieve agent metadata) or 'manycontacts_messages_list' (which might list messages). Without such context, the agent must infer usage, leading to potential misuse.

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 retrieves details but doesn't disclose behavioral traits such as required permissions, rate limits, error handling, or whether it's a read-only operation. The description is minimal and lacks critical context for safe and effective use.

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. It avoids redundancy and wastes no words, though it could be slightly more structured by separating key details. Overall, it's appropriately concise for a simple retrieval tool.

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

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

Given no annotations and no output schema, the description is incomplete for a tool that retrieves complex details like 'scenarios and configuration'. It doesn't explain the return format, data scope, or potential limitations, leaving significant gaps for an AI agent to understand what to expect from the tool's behavior.

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 'id' parameter fully documented as 'AI Agent ID (UUID)'. The description adds no additional parameter semantics beyond what the schema provides, such as format examples or sourcing guidance. Baseline 3 is appropriate since the schema does the heavy lifting.

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

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

The description clearly states the action ('Get details') and resource ('a specific WhatsApp AI agent'), specifying it includes 'scenarios and configuration'. It distinguishes from the sibling 'manycontacts_ai_agents_list' by focusing on a single agent rather than listing multiple. However, it doesn't explicitly differentiate from other 'get' tools like 'manycontacts_contacts_get', which slightly 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 implies usage when details of a specific agent are needed, but provides no explicit guidance on when to use this versus alternatives like 'manycontacts_ai_agents_list' for overviews or 'manycontacts_ai_agents_update' for modifications. There's no mention of prerequisites or exclusions, leaving usage context partially inferred.

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 lists agents but does not disclose behavioral traits such as whether it returns all agents or is paginated, what permissions are required, rate limits, or the format of returned data. This leaves significant gaps for a read operation.

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

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

The description is a single, efficient sentence that front-loads the core purpose ('List AI agents') with necessary context ('configured to auto-respond to WhatsApp Business messages'). There is no wasted verbiage 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 no annotations and no output schema, the description is minimal but adequate for a simple list operation. However, it lacks details on output format, pagination, or error handling, which could be important for an AI agent to use it correctly. It meets minimum viability but has clear gaps.

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

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

The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description appropriately does not discuss parameters, maintaining focus on the tool's purpose. Baseline is 4 for zero parameters.

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

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

The description clearly states the specific action ('List') and resource ('AI agents configured to auto-respond to WhatsApp Business messages'), distinguishing it from sibling tools like manycontacts_ai_agents_get (which retrieves a single agent) and manycontacts_ai_agents_update (which modifies agents). It precisely defines the scope of what is being listed.

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 (when you need to see all configured AI agents for WhatsApp auto-responses), but does not explicitly state when not to use it or name alternatives. It distinguishes from siblings by resource type but lacks explicit guidance on choosing between list vs get operations for agents.

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 this is an update operation, implying mutation, but doesn't disclose behavioral traits such as required permissions, whether changes are reversible, rate limits, or what happens to unspecified configuration fields. 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 that front-loads the core action ('Update a WhatsApp AI agent's configuration') and includes examples. It avoids unnecessary words, though it could be slightly more structured (e.g., separating purpose from examples).

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

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

This is a mutation tool with no annotations and no output schema, yet the description lacks completeness. It doesn't cover behavioral aspects (e.g., permissions, side effects), usage context, or output details. Given the complexity of updating configurations, the description is insufficient 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 already documents all parameters (id, active, block_1, block_2, block_3) with descriptions. The description adds minimal value by hinting at 'instructions, active status, etc.', but doesn't provide additional syntax, format, or constraints beyond what the schema offers.

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 ('WhatsApp AI agent's configuration'), with examples of what can be updated ('instructions, active status, etc.'). However, it doesn't explicitly differentiate from sibling tools like 'manycontacts_ai_agents_get' or 'manycontacts_ai_agents_list', which would be needed for a score of 5.

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

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 agent ID), exclusions, or compare it to related tools like 'manycontacts_ai_agents_get' for retrieval or 'manycontacts_ai_agents_feedback' for other operations.

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

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

No annotations are provided, so the description carries full burden. It mentions the tool sends messages at a scheduled time, which is useful behavioral context. However, it lacks details on permissions required, rate limits, whether the campaign is editable after creation, error handling, or what the response looks like (no output schema). 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 a single, efficient sentence that front-loads the core purpose (create campaign) and includes key details (WhatsApp Business, bulk messaging, template message, phone numbers, scheduled time). Every word earns its place with no 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 (mutation with 5 parameters, no annotations, no output schema), the description is minimally adequate. It covers the basic purpose and scheduling behavior but lacks details on permissions, error cases, or response format. With no annotations or output schema, more context would be helpful for safe invocation.

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

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

Schema description coverage is 100%, so the schema already documents all 5 parameters with descriptions. The description adds no additional parameter semantics beyond what the schema provides (e.g., no examples beyond the schema's ISO format note, no clarification on phone number formats). 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 creates a WhatsApp Business bulk messaging campaign, specifying the action (create), resource (campaign), and scope (sends template message to phone numbers at scheduled time). It distinguishes from sibling tools like manycontacts_campaigns_list and manycontacts_campaigns_delete by focusing on creation rather than listing or deletion.

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 creating scheduled bulk WhatsApp campaigns but does not explicitly state when to use this tool versus alternatives like manycontacts_messages_send_template (for immediate sends) or manycontacts_contacts_bulk (for contact management). No explicit exclusions or prerequisites are mentioned.

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

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

With no annotations provided, the description carries full burden but only states the action without disclosing behavioral traits. It doesn't mention if deletion is permanent, requires specific permissions, has side effects (e.g., affecting associated contacts or messages), or provides any confirmation. This is inadequate for a destructive operation with zero annotation coverage.

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

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

The description is a single, efficient sentence with zero waste—it directly states the tool's purpose without unnecessary words. It's appropriately sized and front-loaded, making it easy to parse quickly.

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

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

For a destructive tool with no annotations and no output schema, the description is incomplete. It lacks critical context such as irreversible effects, error handling, or what happens post-deletion (e.g., confirmation message or status). Given the complexity of deletion operations, this minimal description leaves significant gaps for an AI agent to understand proper 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% with one parameter ('id') clearly documented in the schema. The description doesn't add any parameter semantics beyond what's in the schema (e.g., format examples, validation rules, or where to find the ID). Baseline 3 is appropriate since 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 ('Delete') and resource ('a WhatsApp Business campaign'), providing a specific verb+resource combination. However, it doesn't differentiate from sibling tools like 'manycontacts_campaigns_create' or 'manycontacts_campaigns_list' beyond the obvious verb difference, nor does it specify what constitutes a campaign in this context.

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

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

No guidance is provided on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing campaign ID), consequences (e.g., irreversible deletion), or when to choose deletion over other operations like updating or listing campaigns. The description is purely functional without contextual advice.

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 statistics but doesn't disclose behavioral traits such as pagination, rate limits, authentication requirements, or whether the list is real-time or cached. For a listing tool with zero annotation coverage, this leaves significant gaps in understanding how the tool behaves operationally.

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 ('List WhatsApp Business bulk messaging campaigns') and adds valuable context ('with statistics...'). There's zero waste, and every word earns its place by clarifying scope and output characteristics.

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 (listing with statistics), lack of annotations, and no output schema, the description is minimally adequate. It specifies the resource type and statistics included, but doesn't cover return format, error handling, or operational constraints. For a tool with no structured metadata, more behavioral 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?

The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description doesn't add parameter details, which is appropriate. Baseline is 4 for 0 parameters, as the description correctly focuses on purpose rather than unnecessary parameter explanations.

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 ('WhatsApp Business bulk messaging campaigns'), specifying the exact scope of what's returned. It distinguishes from sibling tools like manycontacts_campaigns_create and manycontacts_campaigns_delete by focusing on listing with statistics rather than creating or deleting campaigns.

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 'with statistics (sent, delivered, read, failed counts)', suggesting this tool is for retrieving campaign performance data. However, it doesn't explicitly state when to use this versus alternatives like manycontacts_funnels_list or manycontacts_messages_list, nor does it provide exclusions 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. While 'List' implies a read-only operation, the description doesn't disclose any behavioral traits like authentication requirements, rate limits, pagination, error conditions, or what 'connected' means operationally. This leaves significant gaps for an agent to understand how to use it effectively.

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

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

The description is a single, efficient sentence that directly states the tool's purpose without any fluff or redundancy. It's appropriately sized and front-loaded, 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 (simple list operation with no parameters) and the absence of annotations and output schema, the description is minimally adequate. It states what the tool does but lacks details on behavior, output format, or usage context. This makes it complete enough for basic understanding but insufficient for optimal agent performance.

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

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

The tool has 0 parameters with 100% schema description coverage, so no parameter information is needed. The description doesn't add parameter semantics, but that's appropriate here. A baseline of 4 is applied as per the rules for 0 parameters, since the schema fully covers the absence of parameters.

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

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

The description clearly states the action ('List') and the resource ('connected WhatsApp Business and Instagram channels'), providing a specific verb+resource combination. However, it doesn't distinguish this tool from other 'list' tools in the sibling set (like manycontacts_ai_agents_list, manycontacts_campaigns_list, etc.), which would require a 5.

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

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

The description provides no guidance on when to use this tool versus alternatives. There's no mention of prerequisites, context, or exclusions. It simply states what the tool does without indicating when it's appropriate.

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 'assign' which implies a mutation operation, but doesn't disclose behavioral traits like required permissions, whether this overwrites existing assignments, error conditions, or what happens on success/failure. This leaves significant gaps for a mutation tool.

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

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

The description is a single, clear sentence that states exactly what the tool does with zero wasted words. It's appropriately sized and front-loaded with the core functionality.

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 doesn't explain what 'assign' means operationally, what permissions are needed, what the response looks like, or how it relates to similar sibling tools. The agent would have significant unanswered questions about using this tool 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%, with both parameters clearly documented in the schema. The description doesn't add any meaningful parameter semantics beyond what the schema already provides (phone format, userId purpose). 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 ('assign') and resource ('WhatsApp Business contact to a team member'), making the purpose specific and understandable. However, it doesn't explicitly differentiate from sibling tools like 'manycontacts_contacts_team_add' or 'manycontacts_contacts_unassign', which appear related to team/assignment 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. With sibling tools like 'manycontacts_contacts_team_add', 'manycontacts_contacts_unassign', and 'manycontacts_contacts_set_stage', there's no indication of how this assignment differs from team additions or when reassignment might be needed.

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 'bulk operations' but doesn't disclose critical behavioral traits: whether these operations are destructive (e.g., 'close' might be irreversible), permission requirements, rate limits, error handling for invalid phones, or what happens if some operations succeed and others fail. The description is minimal and lacks necessary context for safe invocation.

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

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

The description is a single, efficient sentence that lists all key actions without redundancy. It's front-loaded with the core purpose and uses parentheses to compactly enumerate operations, making it easy to parse. Every word earns its place 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 the complexity of bulk operations (multiple actions, potential side effects) and no annotations or output schema, the description is incomplete. It doesn't explain return values, error conditions, or behavioral nuances, leaving significant gaps for an agent to operate safely and effectively in a production environment.

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 clear parameter descriptions and enum values for 'action'. The description adds no additional parameter semantics beyond what's in the schema (e.g., format details for 'phones' or examples for 'value'). Baseline score of 3 is appropriate as the schema does the heavy lifting, but the description doesn't compensate with extra insights.

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 'perform bulk operations' and the resource 'multiple WhatsApp Business contacts', listing the specific actions available (close, open, assign, add_tag, add_team). However, it doesn't explicitly differentiate from sibling tools like manycontacts_contacts_assign or manycontacts_contacts_close, which appear to be single-contact versions, so it doesn't achieve full sibling differentiation.

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

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

The description provides no guidance on when to use this bulk tool versus the individual contact operation tools (e.g., manycontacts_contacts_assign). It lists the actions but doesn't specify prerequisites, constraints, or alternatives, leaving the agent to infer usage context from the tool name alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. While 'Close' implies a state change operation, it doesn't specify whether this is reversible, what permissions are required, whether it affects message history, or what happens after closing. For a mutation tool with zero annotation coverage, this leaves significant behavioral questions unanswered.

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

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

The description is a single, clear sentence with zero wasted words. It's appropriately sized for a simple tool with one parameter and gets straight to the point without unnecessary elaboration.

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

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

For a mutation tool with no annotations and no output schema, the description is insufficient. It doesn't explain what 'closing' means operationally, what the expected outcome is, or whether there are side effects. Given the complexity of conversation state management and the lack of structured behavioral information, the description should provide more context about this 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?

The schema description coverage is 100% with the single parameter 'phone' well-documented in the schema. The description adds no additional parameter information beyond what's already in the schema, so the baseline score 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 ('Close') and target resource ('a WhatsApp Business conversation'), which is specific and unambiguous. However, it doesn't differentiate from the sibling tool 'manycontacts_contacts_open', which would be helpful for distinguishing between opening and closing conversations.

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 'manycontacts_contacts_open' or other contact management tools. There's no mention of prerequisites, consequences, or appropriate contexts for closing conversations.

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 it's a creation tool, implying mutation, but doesn't cover permissions needed, whether duplicates are allowed, error handling, or what happens on success (e.g., returns a contact ID). This leaves significant gaps for a mutation tool.

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

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

The description is a single, clear sentence with no wasted words. It front-loads the key action and resource, making it easy to parse quickly.

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

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

For a mutation tool with no annotations and no output schema, the description is insufficient. It doesn't explain what the tool returns (e.g., a contact object or ID), error conditions, or behavioral nuances like handling duplicate phone numbers, leaving the agent with incomplete operational context.

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

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

Schema description coverage is 100%, so the schema fully documents all three parameters (phone, name, notes). The description adds no additional parameter semantics beyond what's in the schema, such as phone number validation rules or note length limits, meeting 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 ('Create'), the resource ('new WhatsApp Business contact'), and the system ('ManyContacts CRM'). It distinguishes from sibling tools like manycontacts_contacts_update or manycontacts_contacts_get by specifying creation rather than modification or retrieval.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing CRM setup), when not to use it (e.g., for updating existing contacts), or refer to sibling tools like manycontacts_contacts_update for modifications.

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

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

No annotations are provided, so the description carries full burden. It states 'Delete' which implies a destructive operation, but doesn't disclose whether deletion is permanent, reversible, requires specific permissions, or has side effects. The description is minimal and misses key behavioral details for a mutation tool.

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

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

The description is a single, clear sentence that directly states the tool's function without unnecessary words. It's front-loaded and efficiently communicates the core purpose.

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

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

For a destructive operation with no annotations and no output schema, the description is insufficient. It doesn't explain what happens after deletion, potential errors, or return values. Given the complexity and risk of a delete 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%, with the parameter 'phone' documented in the schema. The description doesn't add any meaning beyond what the schema provides about the parameter. Baseline score of 3 is appropriate since 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 ('Delete') and resource ('a WhatsApp Business contact from ManyContacts CRM'), making the purpose immediately understandable. It doesn't explicitly differentiate from sibling tools like 'manycontacts_contacts_delete' vs 'manycontacts_contacts_remove' or other deletion tools, but the specificity is adequate.

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 'manycontacts_contacts_close', 'manycontacts_contacts_unassign', or other deletion-related tools. It lacks context about prerequisites, consequences, or typical scenarios for deletion.

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 it implies a read-only operation ('Get'), it doesn't specify error handling (e.g., if the phone number is invalid or contact doesn't exist), authentication requirements, rate limits, or the format of the returned data. For a tool with no annotation coverage, this leaves significant gaps in understanding its behavior.

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

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

The description is a single, efficient sentence that front-loads the core purpose without unnecessary details. It uses clear language and avoids redundancy, making it easy to parse while conveying essential information about what the tool retrieves.

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 (one parameter, no output schema, no annotations), the description is adequate but incomplete. It covers the basic purpose but lacks behavioral details like error handling or data format, which are crucial for a read operation. Without annotations or an output schema, the description should do more to compensate, but it falls short of being 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 input schema has 100% description coverage, with the single parameter 'phone' clearly documented in the schema. The description doesn't add any additional meaning beyond the schema, such as examples of valid phone number formats or constraints. Since the schema does the heavy lifting, 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 tool's purpose with a specific verb ('Get') and resource ('WhatsApp Business contact'), including the scope of information returned ('tags, teams, and funnel stages'). However, it doesn't explicitly differentiate from sibling tools like 'manycontacts_contacts_list' or 'manycontacts_users_get', which might retrieve similar contact information but with different scopes or formats.

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 whether the contact must exist in the system, or compare it to siblings like 'manycontacts_contacts_list' for bulk retrieval or 'manycontacts_users_get' for user-specific data. Without this context, an agent might struggle to select the appropriate tool.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions 'Returns paginated results,' which is useful, but fails to describe critical behaviors such as authentication requirements, rate limits, error conditions, or what happens when filters yield no results. For a tool with 12 parameters and no 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 extremely concise—just two short sentences that directly state the tool's function and key behavioral trait (pagination). Every word earns its place, with no redundant or vague phrasing, making it easy to parse quickly.

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

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

Given the tool's complexity (12 parameters, no output schema, no annotations), the description is incomplete. It lacks details on authentication, error handling, response format, or pagination structure (e.g., next page tokens). While concise, it doesn't provide enough context for an agent to use the tool effectively without additional assumptions.

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

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

Schema description coverage is 100%, meaning all parameters are documented in the input schema. The description adds minimal value beyond the schema by mentioning 'filters' generically, but doesn't provide additional context on parameter interactions or usage examples. 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 ('List WhatsApp Business contacts') and resource ('contacts'), making the purpose evident. However, it doesn't explicitly differentiate this list operation from other contact-related tools like 'manycontacts_contacts_get' (single contact retrieval) or 'manycontacts_contacts_bulk' (bulk operations), which would be needed for a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. It mentions filters but doesn't specify scenarios where filtering is appropriate or when other tools like 'manycontacts_contacts_get' (for single contacts) or 'manycontacts_funnels_contacts' (for funnel-specific contacts) might be better suited. This leaves the agent without contextual 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 of behavioral disclosure. It states the action ('Reopen') but doesn't describe what reopening entails (e.g., does it restore message history, affect notifications, or require specific permissions?), potential side effects, or error conditions. For a mutation tool with zero annotation coverage, this is a significant gap in transparency.

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

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

The description is a single, direct sentence with no wasted words. It front-loads the core action and resource efficiently, making it easy to parse. Every word contributes to understanding the tool's purpose.

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

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

Given that this is a mutation tool (reopening implies a state change) with no annotations and no output schema, the description is incomplete. It doesn't explain what happens upon reopening (e.g., success indicators, returned data, or error handling), leaving critical behavioral context unspecified 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%, with the single parameter 'phone' fully documented in the schema (type, format example, and requirement). The description doesn't add any parameter-specific information beyond what the schema provides, so it meets the baseline score of 3 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 specific action ('Reopen') and target resource ('a closed WhatsApp Business conversation'), distinguishing it from sibling tools like manycontacts_contacts_close (which closes conversations) and manycontacts_contacts_update (which updates contact details). It uses precise language that leaves no ambiguity about the tool's function.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., the conversation must be closed), exclusions, or related tools like manycontacts_contacts_close for closing conversations. While the name implies it's for reopening, the description lacks explicit usage context.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. While 'Move' implies a mutation operation, it doesn't specify whether this requires special permissions, what happens if the contact is already in that stage, whether the change is reversible, or what side effects might occur. The description lacks crucial behavioral context for a mutation tool.

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

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

The description is a single, efficient sentence that communicates the core functionality without any wasted words. It's appropriately sized for the tool's complexity and gets straight to the point with clear subject-verb-object structure.

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 doesn't explain what happens after the move operation, what success/failure looks like, or any system constraints. Given the complexity of moving contacts between funnel stages in a business context, more behavioral and outcome information would be expected.

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

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

Schema description coverage is 100%, so all parameters are documented in the schema. The description doesn't add any additional semantic context beyond what's already in the schema descriptions (phone format, funnel_id, stage_id). This meets the baseline expectation when schema coverage is complete.

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

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

The description clearly states the action ('Move') and resource ('WhatsApp Business contact to a funnel/pipeline stage'), making the purpose immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'manycontacts_contacts_assign' or 'manycontacts_contacts_update' which might have overlapping functionality, preventing a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. There are multiple sibling contact tools (assign, update, tag_add, etc.) that could potentially serve similar purposes, but the description offers no context about when this specific stage-moving operation is appropriate or what prerequisites might be needed.

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 mutation (adding a tag) but doesn't disclose permissions needed, rate limits, whether tags are unique or cumulative, error handling, or what happens if the tag/contact doesn't exist. This is inadequate for a mutation tool.

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

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

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

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

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

For a mutation tool with no annotations and no output schema, the description is insufficient. It lacks details on behavioral traits (e.g., idempotency, side effects), error cases, or return values, leaving significant gaps for an agent to use it correctly.

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

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

Schema description coverage is 100%, with clear parameter documentation in the schema. The description adds no additional parameter semantics beyond what's in the schema (e.g., format examples or constraints), 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 ('Add a tag') and target resource ('to a WhatsApp Business contact'), providing specific verb+resource information. However, it doesn't differentiate from its sibling 'manycontacts_contacts_tag_remove' beyond the opposite action, missing explicit 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?

No guidance is provided on when to use this tool versus alternatives like 'manycontacts_contacts_update' or 'manycontacts_contacts_bulk'. The description lacks context about prerequisites (e.g., existing contacts/tags) or exclusions, offering only basic functional intent.

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 of behavioral disclosure. It states the action is 'Remove' (implying mutation) but doesn't describe permissions needed, whether the operation is reversible, what happens if the tag doesn't exist, or what the response looks like. This leaves significant behavioral gaps for a mutation tool.

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

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

The description is a single, efficient sentence that states exactly what the tool does with zero wasted words. It's appropriately sized for a simple operation and front-loads the core action.

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

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

For a mutation tool with no annotations and no output schema, the description is insufficient. It doesn't address what happens on success/failure, whether there are side effects, or what permissions are required. The description should provide more behavioral context given the lack of structured metadata.

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

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

Schema description coverage is 100%, so the schema already documents both parameters thoroughly. The description doesn't add any additional meaning beyond what's in the schema - it doesn't explain parameter relationships, format nuances, or edge cases. 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 ('Remove a tag') and target resource ('from a WhatsApp Business contact'), providing specific verb+resource combination. It distinguishes from sibling 'manycontacts_contacts_tag_add' by specifying removal rather than addition, though doesn't explicitly mention this 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 'manycontacts_contacts_update' or 'manycontacts_contacts_tag_add'. There's no mention of prerequisites, context, or exclusions for usage.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It states the action ('Add') which implies a write/mutation operation, but doesn't disclose any behavioral traits: no information about permissions required, whether the operation is idempotent, what happens if the team is already assigned, error conditions, or what the response looks like. 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, clear sentence that states exactly what the tool does with zero wasted words. It's appropriately sized for a simple 2-parameter tool and front-loads the core functionality immediately.

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

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

For a mutation tool with no annotations and no output schema, the description is incomplete. It doesn't address key contextual questions: what happens after adding the team, whether there are side effects, what permissions are needed, or what the return value contains. The agent lacks sufficient information to understand the full implications of using this tool.

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

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

Schema description coverage is 100%, so the schema already fully documents both parameters (phone format, teamId meaning). The description doesn't add any parameter semantics beyond what's in the schema - it doesn't explain the relationship between phone and contact, or what constitutes a valid teamId. Baseline 3 is appropriate when schema does all the work.

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 target resource ('a team to a WhatsApp Business contact'), making the purpose immediately understandable. It distinguishes from sibling tools like 'manycontacts_contacts_team_remove' by specifying the opposite operation. However, it doesn't explicitly mention what 'team' means in this context or how it relates to the contact.

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., contact must exist, team must exist), nor does it differentiate from similar tools like 'manycontacts_contacts_assign' or 'manycontacts_contacts_tag_add'. The agent must infer usage from the tool name alone.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It states the action is 'Remove' which implies a destructive mutation, but doesn't specify whether this is reversible, what permissions are required, whether it affects contact history, or what happens if the team isn't currently assigned. The description is minimal and lacks important 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 directly states the tool's purpose with zero waste. It's appropriately sized for a simple operation and front-loads the essential information 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 mutation tool with no annotations and no output schema, the description is inadequate. It doesn't explain what happens after removal, whether there's confirmation or error handling, what the response looks like, or how this affects the contact's state. The minimal description leaves too many behavioral questions unanswered.

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 ('phone' and 'teamId') clearly documented in the schema. The description doesn't add any additional semantic context about these parameters beyond what's already in the schema, so the baseline score 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 ('Remove') and target ('a team from a WhatsApp Business contact'), providing a specific verb+resource combination. However, it doesn't explicitly differentiate from its sibling 'manycontacts_contacts_team_add' beyond the opposite action, missing an opportunity to clarify the relationship between these complementary 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 about when to use this tool versus alternatives. The description doesn't mention prerequisites (e.g., the contact must already have the team assigned), error conditions, or relationships with sibling tools like 'manycontacts_contacts_team_add' for the inverse 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?

No annotations are provided, so the description carries the full burden. It states this is a mutation ('unassign'), implying it modifies data, but doesn't disclose behavioral traits such as permissions required, whether the change is reversible, error conditions (e.g., if contact isn't assigned), or side effects. This leaves significant gaps for a mutation tool.

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

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

The description is a single, efficient sentence that front-loads the key action and resource. There is no wasted language, and it directly conveys the tool's purpose without redundancy.

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

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

Given the tool's complexity (a mutation with no annotations and no output schema), the description is minimal. It states what the tool does but lacks completeness in behavioral context, error handling, or output details. For a mutation tool, this is a moderate gap, though the concise purpose helps.

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 'phone' documented as 'Phone number with country code, e.g. 34600000000'. The description adds no additional parameter semantics beyond what the schema provides, such as format details or validation rules, 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 specific action ('unassign'), the resource ('WhatsApp Business contact'), and the effect ('remove user assignment'). It distinguishes from sibling tools like 'manycontacts_contacts_assign' (which assigns contacts) and 'manycontacts_contacts_update' (which might update other fields).

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 specifying 'WhatsApp Business contact' and 'remove user assignment', suggesting it's for managing contact assignments. However, it doesn't explicitly state when to use this versus alternatives like 'manycontacts_contacts_update' for other changes or 'manycontacts_contacts_delete' for removal, nor does it mention prerequisites like needing an assigned contact first.

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 this is an update operation, implying mutation, but lacks critical behavioral details: it doesn't specify required permissions, whether updates are reversible, how partial updates are handled (e.g., if only 'name' is provided, are 'notes' cleared?), rate limits, or error conditions (e.g., what happens if 'phone' doesn't exist?). The description is too minimal for a mutation tool with no annotation support.

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

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

The description is a single, efficient sentence that front-loads the core action ('Update an existing WhatsApp Business contact') and specifies the updatable 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?

Given the tool's complexity (mutation operation with 4 parameters, no annotations, and no output schema), the description is incomplete. It lacks behavioral context (e.g., side effects, error handling), usage guidelines, and details on the response format. For a tool that modifies data, this minimal description leaves significant gaps for an AI agent to infer correct 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%, with each parameter documented in the schema (e.g., 'phone' requires country code, 'customFields' as JSON string). The description adds marginal value by listing the updatable fields (name, notes, custom fields), but doesn't provide additional semantics beyond what the schema already covers, such as format examples for 'customFields' or constraints on 'name' length.

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 ('existing WhatsApp Business contact'), specifying the updatable fields (name, notes, custom fields). It distinguishes from sibling tools like 'manycontacts_contacts_create' and 'manycontacts_contacts_delete' by focusing on updates, but doesn't explicitly differentiate from other update-related tools like 'manycontacts_contacts_assign' or 'manycontacts_contacts_set_stage'.

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., contact must exist), exclusions (e.g., cannot update certain fields), or comparisons to siblings like 'manycontacts_contacts_bulk' for multiple updates or 'manycontacts_contacts_get' to check current values before updating.

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 implies a read-only operation ('Get') and describes the scope of data returned, which helps the agent understand this is a safe, informational tool. However, it doesn't disclose potential behavioral traits like rate limits, authentication requirements, or data freshness, leaving some gaps for a tool with no annotation coverage.

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

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

The description is front-loaded with the core purpose in the first sentence and a usage guideline in the second, with zero wasted words. Every sentence earns its place by providing essential information without redundancy or fluff.

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

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

Given the tool's complexity (simple read operation with no parameters) and lack of annotations/output schema, the description is fairly complete—it explains what data is returned and when to use it. However, it could be more comprehensive by mentioning the response format or any limitations, though this is mitigated by the tool's straightforward nature.

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

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

The tool has 0 parameters with 100% schema description coverage, so the baseline is 4. The description adds no parameter-specific information, which is acceptable since no parameters exist, but it doesn't compensate for any gaps (as there are none).

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

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

The description clearly states the tool's purpose with specific verbs ('Get') and resources ('ManyContacts account overview'), listing concrete data points like WhatsApp Business channels, contact/user/tag counts, active AI agents, and enabled features. It effectively distinguishes itself from sibling tools by focusing on account-level overview rather than operations on specific entities like contacts, campaigns, or users.

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

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

The description provides explicit usage guidance with 'Use this first to understand the account state,' indicating it should be invoked as an initial step to gather context before using other tools. This clearly distinguishes when to use it versus alternatives like specific entity operations (e.g., manycontacts_contacts_list or manycontacts_users_get).

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. While 'Add' implies a write/mutation operation, the description doesn't specify permissions required, whether this operation is idempotent, what happens on duplicate stage names, or what the response contains. For a mutation tool with zero annotation coverage, this leaves significant behavioral questions unanswered.

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

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

The description is a single, efficient sentence with zero wasted words. It's appropriately sized for the tool's apparent complexity and gets straight to the point without unnecessary elaboration.

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

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

For a mutation tool with no annotations and no output schema, the description is insufficient. It doesn't explain what happens after adding a stage, what the response looks like, error conditions, or how this interacts with other funnel operations. Given the presence of sibling funnel tools and the mutation nature of the operation, more 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?

Schema description coverage is 100%, so the schema already documents all three parameters (funnelId, name, order) with basic descriptions. The description adds no additional parameter context beyond what's in the schema - no examples, format requirements, constraints, or relationships between parameters. 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 ('Add a stage') and the target resource ('to a sales funnel/pipeline'), providing a specific verb+resource combination. However, it doesn't differentiate from sibling tools like 'manycontacts_funnels_update_stage' or 'manycontacts_funnels_create', which could create ambiguity about when to use each funnel-related 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. With sibling tools like 'manycontacts_funnels_update_stage' and 'manycontacts_funnels_create' present, the agent has no indication whether this is for creating new funnels, modifying existing stages, or adding stages to existing funnels. No prerequisites or context for usage is mentioned.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It mentions the list operation and optional filtering, but doesn't describe important behavioral aspects: whether this is paginated (though parameters suggest it), what the return format looks like, rate limits, authentication requirements, or error conditions. For a list operation with 4 parameters, 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 immediately states the core functionality. Every word earns its place: 'List contacts' (action+resource), 'in a funnel/pipeline' (context), 'optionally filtered by stage' (key capability). There's no wasted verbiage 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 and no output schema, the description is minimally adequate. It covers the basic purpose and filtering capability, but lacks details about return format, pagination behavior, error handling, or relationship to sibling tools. Given the complexity (funnel/contact relationships) and absence of annotations/output schema, more context would be helpful for an agent to use this 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 all parameters are documented in the schema. The description adds minimal value beyond the schema - it mentions filtering by stage (which corresponds to 'stage_id') but doesn't provide additional context about funnel/stage relationships or pagination behavior. The baseline of 3 is appropriate since the schema does the heavy lifting, though the description could have added more semantic context.

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 contacts') and resource ('in a funnel/pipeline'), making the purpose immediately understandable. It distinguishes this tool from general contact listing tools like 'manycontacts_contacts_list' by specifying the funnel/pipeline context. However, it doesn't explicitly differentiate from other funnel-related tools like 'manycontacts_funnels_list' (which likely lists funnels themselves rather than contacts within 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?

The description implies usage context ('in a funnel/pipeline') and provides optional filtering ('optionally filtered by stage'), giving some guidance about when this tool is appropriate. However, it doesn't explicitly state when to use this versus alternatives like 'manycontacts_contacts_list' (for all contacts) or 'manycontacts_funnels_list' (for funnel metadata), 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 the tool creates a funnel, implying a write operation, but doesn't cover aspects like required permissions, whether the creation is idempotent, what happens on failure, or the expected response format. This leaves significant gaps for a mutation tool.

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

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

The description is a single, direct sentence that efficiently conveys the core action and resource without any fluff or redundancy. It's front-loaded and appropriately sized for its purpose.

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

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

Given the tool is a mutation (create operation) with no annotations and no output schema, the description is insufficient. It lacks details on behavioral traits, error handling, or return values, making it incomplete for safe and effective use by an AI agent in this context.

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

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

The input schema has 100% description coverage, with the 'name' parameter documented as 'Funnel name'. The description doesn't add any extra meaning beyond this, such as examples or constraints, so it meets the baseline for high schema coverage without compensating 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 ('Create') and the resource ('a new sales funnel/pipeline for WhatsApp Business contacts'), making the purpose evident. However, it doesn't explicitly differentiate from sibling tools like 'manycontacts_funnels_add_stage' or 'manycontacts_funnels_update_stage', which also involve funnel operations, so it doesn't fully achieve 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 'manycontacts_funnels_list' for viewing funnels or 'manycontacts_funnels_delete' for removal. There's no mention of prerequisites, context, or exclusions, leaving usage unclear relative to siblings.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states 'Delete' which implies a destructive mutation, but fails to mention critical aspects like whether deletion is permanent, requires specific permissions, has side effects (e.g., on associated contacts), or what the response looks like. This leaves significant gaps for a mutation tool.

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

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, which is ideal for conciseness.

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

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

For a destructive mutation tool with no annotations and no output schema, the description is insufficient. It lacks details on behavioral traits (e.g., irreversibility, permissions), response format, or error handling. Given the complexity and risk of deletion, more context is needed to be 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 'id' documented as 'Funnel ID to delete'. The description adds no additional parameter information beyond what the schema provides, such as format examples or sourcing details. Given the high schema coverage, a 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 action ('Delete') and the resource ('a sales funnel/pipeline'), providing a specific verb+resource combination. However, it doesn't differentiate from sibling tools like 'manycontacts_funnels_create' or 'manycontacts_funnels_list' beyond the obvious action difference, missing explicit scope or type distinctions that would warrant a 5.

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

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

No guidance is provided on when to use this tool versus alternatives. The description lacks context about prerequisites (e.g., needing an existing funnel), exclusions, or comparisons to related tools like 'manycontacts_funnels_update_stage', 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?

No annotations are provided, so the description carries the full burden. It states a list operation, implying read-only behavior, but doesn't disclose critical details like pagination, sorting, filtering options, rate limits, or authentication requirements. For a list tool with zero annotation coverage, this leaves significant behavioral gaps.

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

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

The description is a single, efficient sentence that front-loads the core purpose ('List sales funnels/pipelines') and adds context without waste. Every word earns its place, 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 simplicity (0 parameters, no output schema), the description is adequate but has gaps. It lacks behavioral details like response format or error handling, which are important for a list operation. With no annotations and no output schema, the description should ideally provide more context about what the list returns.

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 parameters need documentation. The description doesn't add parameter details, which is appropriate here. A baseline of 4 is given since the schema fully covers the lack of parameters, and the description doesn't need to compensate.

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

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

The description clearly states the action ('List') and resource ('sales funnels/pipelines'), with specific context about organizing WhatsApp Business contacts by stage. It distinguishes from siblings like 'manycontacts_funnels_create' or 'manycontacts_funnels_delete' by indicating a read operation. However, it doesn't explicitly differentiate from 'manycontacts_funnels_contacts' or 'manycontacts_funnels_update_stage', which are related but not identical.

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 existing funnels to list, or compare it to similar tools like 'manycontacts_funnels_contacts' (which might list contacts within funnels). Without explicit usage context, the agent must infer based on the name alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. While 'Update' implies a mutation operation, the description doesn't disclose important behavioral aspects like permission requirements, whether this operation is reversible, what happens to existing stage data, or any rate limits. For a mutation tool with zero annotation coverage, this represents a significant gap in transparency.

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

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

The description is a single, efficient sentence that communicates the core purpose without unnecessary words. It's appropriately sized for what it does convey, though it could benefit from additional context about usage and behavior.

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 insufficiently complete. It doesn't explain what happens after the update, what the response looks like, error conditions, or important behavioral constraints. The combination of mutation operation + zero annotations + no output schema requires more comprehensive description than provided.

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 all parameters are documented in the schema itself. The description doesn't add any meaningful parameter semantics beyond what's already in the schema (funnelId, stageId, name). This meets the baseline expectation when schema coverage is complete.

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 ('a stage in a sales funnel/pipeline'), making the purpose immediately understandable. However, it doesn't distinguish this tool from sibling tools like 'manycontacts_funnels_add_stage' or 'manycontacts_funnels_delete', which would require more specific differentiation.

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

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

The description provides no guidance on when to use this tool versus alternatives. There are multiple funnel-related tools in the sibling list (add_stage, delete, list, create), but the description doesn't indicate when this update operation is appropriate versus creating a new stage or modifying other funnel properties.

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 tool lists messages with timestamps and status, which gives some output context, but doesn't address critical behaviors like pagination (implied by page/limit parameters but not explained), rate limits, authentication requirements, or whether it's read-only (implied by 'List' but not stated).

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 WhatsApp Business messages for a contact') and adds useful detail ('Shows the conversation history with timestamps and status'). There is no wasted language, and it's appropriately sized for a list tool.

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

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

Given the tool's moderate complexity (list operation with pagination), no annotations, and no output schema, the description is minimally adequate. It covers the basic purpose and output format but lacks details on behavioral traits, error handling, or when to use alternatives. It's complete enough to understand what the tool does but not how to use it effectively.

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

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

Schema description coverage is 100%, so the schema fully documents the three parameters (phone, page, limit). The description adds no additional parameter semantics beyond what the schema provides, such as format examples for phone or usage tips for pagination. 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 ('WhatsApp Business messages for a contact'), specifying it shows conversation history with timestamps and status. It distinguishes from sibling tools like manycontacts_messages_send_text or manycontacts_messages_send_note, but doesn't explicitly differentiate from other list tools like manycontacts_contacts_list or manycontacts_templates_list.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, such as needing an existing contact or specific permissions, nor does it compare to other messaging-related tools like manycontacts_messages_send_text. Usage is implied by the purpose but lacks explicit 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 it clarifies the note is 'internal' and 'not visible to the contact', it doesn't mention important behavioral aspects like whether this requires specific permissions, if notes are permanent or editable, rate limits, or what happens on success/failure. For a mutation tool with zero annotation coverage, this leaves significant gaps in understanding the tool's behavior.

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

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

The description is a single, efficient sentence that communicates the essential information without any wasted words. It's appropriately sized for a tool with two parameters and gets straight to the point about what the tool does and its key characteristic (internal/not visible).

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 provides basic purpose and privacy context but lacks important behavioral details. It doesn't explain what happens after sending the note, potential error conditions, or system implications. The description is adequate as a minimum viable explanation but has clear gaps given the tool's mutation nature and lack of structured behavioral metadata.

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 ('phone' and 'body') clearly documented in the schema. The description doesn't add any parameter-specific information beyond what's already in the schema descriptions. According to scoring rules, when schema coverage is high (>80%), the baseline is 3 even without additional param info in the description.

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

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

The description clearly states the specific action ('Send an internal note'), the target resource ('on a WhatsApp Business contact'), and distinguishes it from similar tools by specifying 'not visible to the contact'. This differentiates it from sibling messaging tools like 'manycontacts_messages_send_template' or 'manycontacts_messages_send_text' that likely send visible messages.

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

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

The description provides clear context about when to use this tool: for sending internal notes on WhatsApp contacts. It implies usage for private annotations rather than customer-facing communication. However, it doesn't explicitly state when NOT to use it or name specific alternatives among the sibling tools, though the distinction from visible messaging tools is strongly implied.

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

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

With no annotations provided, the description carries full burden but only states the action without disclosing behavioral traits. It doesn't mention authentication requirements, rate limits, error conditions, whether the message is queued or sent immediately, or what happens on success/failure. For a messaging 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 a single, efficient sentence with a clarifying parenthetical. Every word earns its place - it states the action, specifies the message type, and provides crucial usage context without any redundancy or unnecessary elaboration.

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

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

For a messaging tool with no annotations and no output schema, the description provides adequate purpose and context but lacks behavioral details. The 100% schema coverage helps with parameters, but the absence of output information and behavioral transparency makes this incomplete for confident tool invocation.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters thoroughly. The description doesn't add any parameter-specific information beyond what's in the schema descriptions. This meets the baseline of 3 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 ('Send a WhatsApp Business template message') and specifies the resource ('template message'), with the parenthetical adding crucial context about its use case ('for outbound messaging outside the 24h window'). It distinguishes from sibling tools like 'manycontacts_messages_send_text' by specifying template-based messaging.

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

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

The description provides clear context about when to use this tool ('for outbound messaging outside the 24h window'), which implicitly suggests it's not for regular conversations within the 24-hour window. However, it doesn't explicitly mention when not to use it or name specific alternatives like 'manycontacts_messages_send_text' for non-template messages.

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

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

With no annotations provided, the description carries full burden but only states the basic action. It doesn't disclose behavioral traits such as authentication requirements, rate limits, error conditions, whether it's idempotent, or what happens on success/failure. 'Send' implies a write operation, but no further context is given.

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

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

The description is a single, efficient sentence that directly states the tool's purpose without any wasted words. It's appropriately sized and 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 mutation tool with no annotations and no output schema, the description is insufficient. It lacks information about return values, error handling, side effects, and integration context (e.g., WhatsApp Business API specifics). The description doesn't compensate for the missing structured data.

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 (phone and body) adequately. The description adds no additional parameter semantics beyond what's in the schema, 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 ('Send') and resource ('WhatsApp Business text message') with the target ('to a phone number'). It distinguishes from sibling tools like manycontacts_messages_send_note and manycontacts_messages_send_template by specifying 'text message', 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 manycontacts_messages_send_template or manycontacts_messages_send_note. The description only states what it does, not when it's appropriate or any 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 full burden. 'Get' implies a read operation, but it doesn't disclose whether this requires special permissions, if the API key is sensitive data with access restrictions, what format the key is returned in, or any rate limits. The description states the basic action but lacks important behavioral context for a security-sensitive 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, clear sentence with no wasted words. It's perfectly front-loaded, immediately communicating the core purpose without unnecessary elaboration. Every word earns its place in this minimal but complete 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 zero-parameter tool with no output schema, the description adequately states what it does. However, given that this retrieves potentially sensitive API key information and has no annotations, the description should ideally mention security considerations or return format. It's minimally complete but could be more helpful for an agent handling authentication data.

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

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

The tool has 0 parameters with 100% schema description coverage, so the schema already fully documents the absence of parameters. The description doesn't need to explain parameters, and it correctly implies this is a simple retrieval without inputs. Baseline for 0 parameters is 4, as the description appropriately doesn't waste space on non-existent 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 'Get the organization API key' clearly states the verb 'Get' and the resource 'organization API key', making the purpose immediately understandable. However, it doesn't differentiate this tool from its sibling 'manycontacts_org_get' which might also retrieve organization information, leaving some ambiguity about their distinct roles.

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

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

The description provides no guidance on when to use this tool versus alternatives. With sibling tools like 'manycontacts_org_get' that might retrieve general organization data, there's no indication whether this tool is for retrieving specifically the API key versus other organization properties, or any prerequisites for its use.

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 it's a read operation ('Get'), but doesn't mention whether it requires specific permissions, rate limits, authentication needs, or what happens on failure. 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 key information: verb, resource, and specific data returned. There's no wasted wording, and it directly communicates the tool's function without unnecessary elaboration.

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

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

Given the tool has 0 parameters, no output schema, and no annotations, the description is minimally adequate. It states what the tool does but lacks details on behavioral aspects (e.g., authentication, error handling) and doesn't explain the return format. For a simple read tool, it meets basic needs but could be more complete by addressing missing context.

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

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

The tool has 0 parameters, and schema description coverage is 100% (empty schema). The description doesn't need to add parameter details, so it appropriately focuses on the tool's purpose. A baseline of 4 is applied since no parameters exist, and the description doesn't attempt to explain nonexistent inputs.

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

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

The description clearly states the verb 'Get' and the resource 'WhatsApp Business organization/account information', specifying what information is retrieved (name, timezone, settings). It distinguishes from siblings like 'manycontacts_org_update' by focusing on retrieval rather than modification. However, it doesn't explicitly differentiate from other 'get' tools like 'manycontacts_contacts_get' 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., authentication needs), when not to use it, or how it compares to related tools like 'manycontacts_org_schedule_get' or 'manycontacts_org_apikey'. Usage is implied by the verb 'Get', but no explicit context is given.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It states it's a 'Get' operation (implying read-only), but doesn't mention authentication requirements, rate limits, error conditions, or what the response format looks like. For a tool with zero annotation coverage, this leaves significant behavioral gaps.

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

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

The description is a single, clear sentence that states exactly what the tool does with no wasted words. It's appropriately sized for a simple retrieval tool and front-loads the essential information.

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

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

For a zero-parameter read operation with no output schema, the description provides the core purpose but lacks important context. Without annotations or output schema, it should ideally mention what information is returned (e.g., hours format, timezone) and any authentication requirements. The description is minimally adequate but has clear gaps.

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

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

The tool has zero parameters with 100% schema description coverage, so the schema already fully documents the lack of parameters. The description appropriately doesn't discuss parameters, maintaining focus on the tool's purpose. A baseline of 4 is appropriate for zero-parameter tools.

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

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

The description clearly states the action ('Get') and the resource ('business hours schedule for the WhatsApp Business account'), making the purpose immediately understandable. It doesn't explicitly differentiate from sibling tools like 'manycontacts_org_get', but the specificity of 'business hours schedule' provides some implicit 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. There's no mention of prerequisites, context, or comparison to sibling tools like 'manycontacts_org_get' (which might retrieve general organization information). Usage is implied only by 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 the full burden of behavioral disclosure. It states this is an update operation (implying mutation), but doesn't mention important behavioral aspects like required permissions, whether changes are reversible, rate limits, error conditions, or what happens to unspecified settings. For a mutation tool with 10 parameters, 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 immediately communicates the core purpose. Every word earns its place - 'Update' (action), 'WhatsApp Business organization settings' (target), and examples of what can be updated. There's no wasted verbiage or unnecessary elaboration.

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

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

For a mutation tool with 10 parameters and no annotations or output schema, the description is insufficiently complete. It doesn't address critical context like authentication requirements, side effects, error handling, or what constitutes a successful update. The agent lacks necessary information to use this tool safely and effectively despite the comprehensive parameter schema.

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%, with all 10 parameters well-documented in the schema itself. The description adds minimal value beyond the schema by listing example categories ('timezone, auto-reply, webhooks, etc.') but doesn't provide additional context about parameter interactions, defaults, or constraints. 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 verb ('Update') and resource ('WhatsApp Business organization settings'), and provides specific examples of what can be updated ('timezone, auto-reply, webhooks, etc.'). However, it doesn't explicitly differentiate from its sibling 'manycontacts_org_get' (which presumably reads the same settings), so it doesn't reach the highest score.

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

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

The description provides no guidance on when to use this tool versus alternatives. There's no mention of prerequisites, when not to use it, or how it relates to sibling tools like 'manycontacts_org_get' (for reading settings) or other update tools in the system. The agent must infer usage from the tool name alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. While 'Create a new tag' implies a write operation, it doesn't address important behavioral aspects like required permissions, whether tag names must be unique, what happens on duplicate names, rate limits, or what the response contains. This leaves significant gaps for a mutation tool.

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

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

The description is a single, efficient sentence that states the core purpose without unnecessary words. It's appropriately sized for a simple creation tool and gets straight to the point.

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 doesn't explain what happens after creation, whether there are constraints on tag creation, how this integrates with the broader system, or what the agent should expect as a result. The context signals indicate this is a non-trivial operation that requires more guidance.

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

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

Schema description coverage is 100%, so the schema already fully documents both parameters (name and color). The description doesn't add any parameter-specific information beyond what's in the schema, such as naming conventions, color palette restrictions, or default behavior 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 ('Create a new tag') and the resource ('for WhatsApp Business contacts'), which provides a specific verb+resource combination. However, it doesn't explicitly differentiate from sibling tools like 'manycontacts_tags_update' or 'manycontacts_tags_delete' beyond the obvious 'create' vs 'update/delete' 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. There's no mention of prerequisites, when-not-to-use scenarios, or how this relates to sibling tools like 'manycontacts_tags_list' or 'manycontacts_contacts_tag_add'.

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

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

With no annotations provided, the description carries full burden but only states the action without behavioral details. It doesn't disclose if deletion is permanent, requires specific permissions, has side effects (e.g., removing tags from contacts), or error conditions (e.g., invalid ID). This is inadequate for a mutation tool.

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

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

The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's appropriately sized and front-loaded, 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?

For a deletion tool with no annotations and no output schema, the description is incomplete. It lacks critical context like behavioral traits (e.g., permanence, permissions), usage guidelines, and output expectations, leaving significant gaps for an AI agent.

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

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

The input schema has 100% description coverage, with the 'id' parameter clearly documented as 'Tag ID to delete'. The description adds no additional parameter semantics beyond this, so it meets the baseline of 3 where 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 ('Delete') and the resource ('a WhatsApp Business contact tag'), making the purpose unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'manycontacts_tags_update' or 'manycontacts_contacts_tag_remove', which would require a 5.

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

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

The description provides no guidance on when to use this tool versus alternatives. There's no mention of prerequisites (e.g., tag must exist), exclusions (e.g., cannot delete if in use), or sibling tools like 'manycontacts_tags_update' for modifications.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It states this is a list operation, implying it's read-only, but doesn't mention any behavioral traits like pagination, rate limits, authentication requirements, or what format the tags are returned in. For a 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 a single, efficient sentence that communicates the essential purpose without any wasted words. It's appropriately sized for a simple list operation and front-loads the key information ('List all tags').

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

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

For a simple list tool with no parameters and no output schema, the description provides the basic purpose but lacks important context. Without annotations or output schema, it should ideally mention what the response contains (e.g., tag names, IDs, metadata) or any behavioral considerations. The description is minimally adequate but has clear gaps.

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

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

The tool has 0 parameters with 100% schema description coverage, so the schema fully documents the absence of inputs. The description appropriately doesn't discuss parameters, which is correct for a parameterless tool. A baseline of 4 is appropriate since no parameter information is needed.

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

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

The description clearly states the action ('List all tags') and resource ('for categorizing WhatsApp Business contacts'), providing a specific verb+resource combination. However, it doesn't distinguish this tool from sibling tag-related tools like 'manycontacts_tags_create' or 'manycontacts_tags_update', which would require explicit differentiation to earn a 5.

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

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

The description provides no guidance on when to use this tool versus alternatives. There's no mention of prerequisites, timing considerations, or comparison to sibling tools like 'manycontacts_contacts_tag_add' or 'manycontacts_contacts_tag_remove'. The agent must infer usage from the name alone.

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

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

No annotations are provided, so the description carries full burden. It states this is an update operation, implying mutation, but doesn't disclose behavioral traits such as required permissions, whether changes are reversible, error handling, or rate limits. For a mutation tool with zero annotation coverage, this is a significant gap in transparency.

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

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

The description is a single, efficient sentence that front-loads the core purpose ('Update an existing WhatsApp Business contact tag') with zero waste. It's appropriately sized for a straightforward tool, earning its place without unnecessary elaboration.

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

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

Given this is a mutation tool with no annotations and no output schema, the description is incomplete. It lacks crucial context such as what the update returns, error conditions, or side effects (e.g., whether it affects tagged contacts). For a tool with three parameters and potential behavioral complexity, more information is needed to guide an agent effectively.

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

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

Schema description coverage is 100%, so the schema already documents all parameters (id, name, color) with descriptions. The description adds no additional meaning beyond what's in the schema, such as explaining that 'id' refers to an existing tag or providing examples for 'color' values. 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 ('Update') and resource ('existing WhatsApp Business contact tag'), which is specific and unambiguous. However, it doesn't differentiate this tool from sibling tools like 'manycontacts_tags_create' or 'manycontacts_tags_delete', which would require mentioning it modifies existing tags rather than creating or deleting 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?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing tag ID), exclusions, or comparisons to sibling tools like 'manycontacts_tags_create' for new tags or 'manycontacts_contacts_tag_add' for tagging contacts, leaving the agent to infer usage context.

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