YCloud WhatsApp API MCP Server

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v1.0.0
Disambiguation4/5
Most tools have distinct purposes targeting specific WhatsApp API resources (WABAs, messages, phones, templates) with clear action verbs. However, wa_msg_send and wa_msg_send_directly could cause confusion as they both send messages with only a delivery timing distinction that might not be immediately clear from the names alone.
Naming Consistency5/5
All tool names follow a consistent snake_case pattern with a clear wa_resource_action structure (e.g., wa_business_list, wa_msg_send, wa_template_create). The naming convention is predictable and uniform across all 19 tools, making them easily parsable.
Tool Count4/5
With 19 tools, the count is slightly high but reasonable for a comprehensive WhatsApp API server covering multiple resource types (businesses, messages, phones, templates). It provides detailed operations without being overwhelmingly large, though it borders on the heavy side.
Completeness5/5
The tool set offers complete CRUD/lifecycle coverage for all key WhatsApp API domains: WABAs (list/retrieve), messages (send/retrieve/mark read), phone numbers (list/register/retrieve/update settings and profile), and templates (create/edit/get/list/delete). No obvious gaps exist for typical agent workflows.
Average 2.3/5 across 19 of 19 tools scored. Lowest: 1.7/5.
See the Tool Scores section below for per-tool breakdowns.
This repository is archived. Archived repositories automatically receive an F maintenance tier.
Add a LICENSE file by following GitHub's guide. Once GitHub recognizes the license, the system will automatically detect it within a few hours.
If the license does not appear after some time, you can manually trigger a new scan using the MCP server admin interface.
MCP servers without a LICENSE cannot be installed.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior1/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden but offers no behavioral details. It does not disclose permissions needed, rate limits, side effects, or response format, which is critical for a messaging tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise with a single sentence, 'Send a message directly', which is front-loaded and wastes no words, though this brevity contributes to its inadequacy in other dimensions.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
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, no output schema, and an undocumented parameter, the description is completely inadequate. It lacks essential context like target recipient, message type, or error handling, making it insufficient for effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 1 parameter with 0% description coverage, and the description adds no information about the 'body' parameter's meaning, format, or constraints, failing to compensate for the schema's lack of detail.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose2/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Send a message directly' restates the tool name 'wa_msg_send_directly' with minimal elaboration, making it tautological. It specifies the verb 'send' and resource 'message' but lacks detail about what distinguishes it from sibling tools like 'wa_msg_send' or the context of 'directly'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines1/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives, such as 'wa_msg_send'. The description does not mention prerequisites, exclusions, or specific scenarios, leaving usage unclear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior1/5
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. 'Retrieve' implies a read operation, but the description doesn't disclose any behavioral traits such as authentication requirements, rate limits, error conditions, or what format the commerce settings are returned in. This is inadequate for a tool with zero annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise at just two words, with no wasted language. While this conciseness comes at the cost of completeness, from a pure structure perspective, every word serves a purpose and there's no unnecessary verbiage.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given that this is a retrieval tool with 2 required parameters, 0% schema description coverage, no annotations, and no output schema, the description is completely inadequate. It doesn't explain what commerce settings are, what the parameters mean, what format results are returned in, or how this differs from similar tools. The description fails to provide the necessary context for effective tool use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 0% description coverage for both parameters (wabaId and phoneNumber), and the tool description provides absolutely no information about what these parameters mean, their format, or how they should be used. With two required parameters and no schema descriptions, the description fails to compensate for this documentation gap.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose2/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Retrieve commerce settings' is a tautology that essentially restates the tool name 'wa_phone_retrieve_commerce_settings'. While it identifies the action ('retrieve') and resource ('commerce settings'), it doesn't provide any specific context about what commerce settings are or how this differs from similar tools like 'wa_phone_retrieve' or 'wa_phone_retrieve_profile'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines1/5
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 'wa_phone_retrieve', 'wa_phone_retrieve_profile', and 'wa_phone_update_commerce_settings', there's no indication of when this specific commerce settings retrieval is appropriate versus general phone retrieval or profile retrieval tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior1/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. 'Update commerce settings' implies a mutation operation but reveals nothing about required permissions, whether changes are reversible, rate limits, error conditions, or what happens to existing settings not mentioned. For a mutation tool with zero annotation coverage, this is completely inadequate.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is maximally concise at just two words. While this represents severe under-specification rather than ideal conciseness, from a pure structural perspective there's zero waste - every word directly contributes to the minimal purpose statement. No fluff or redundant phrasing exists.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
This is a mutation tool with 3 parameters, 0% schema description coverage, no annotations, and no output schema. The description provides only a basic verb+object statement without explaining what commerce settings are, what parameters mean, what permissions are needed, what the operation does, or what it returns. For this level of complexity, the description is completely inadequate.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, meaning none of the 3 parameters (wabaId, phoneNumber, body) are documented in the schema. The description adds no parameter information whatsoever - it doesn't explain what wabaId or phoneNumber represent, what format they should be in, or what the body parameter should contain. The description fails to compensate for the complete lack of schema documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose2/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Update commerce settings' is a tautology that essentially restates the tool name 'wa_phone_update_commerce_settings'. While it indicates the action (update) and target (commerce settings), it doesn't specify what commerce settings are or what resource they belong to. It doesn't distinguish this tool from its sibling 'wa_phone_update_profile' which also updates settings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines1/5
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 this operation is appropriate, or how it differs from related tools like 'wa_phone_retrieve_commerce_settings' or 'wa_phone_update_profile'. The agent receives no contextual usage information.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior1/5
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 but fails completely. 'Create a template' implies a write/mutation operation but doesn't specify what permissions are needed, whether the creation is immediate or requires approval, what happens on failure, or what the response contains. For a mutation tool with zero annotation coverage, this is critically inadequate.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is maximally concise with just two words. While this represents severe under-specification, from a pure conciseness perspective, it's efficient with zero wasted words. Every word earns its place, though there are far too few words to be helpful.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given this is a mutation tool (create operation) with no annotations, 0% schema description coverage, no output schema, and multiple sibling tools, the description is completely inadequate. It doesn't explain what gets created, how to use it, what parameters are needed, what the response looks like, or when to choose this tool over alternatives. This fails to provide the minimal context needed for effective tool use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 1 parameter ('body') with 0% schema description coverage, meaning the schema provides no documentation about this parameter. The description offers no information about what the 'body' parameter should contain, its format, structure, or required fields. For a single undocumented parameter, the description should compensate but provides zero parameter semantics.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose2/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Create a template' is a tautology that merely restates the tool name 'wa_template_create'. It doesn't specify what kind of template (WhatsApp message template), what platform it's for, or what the template contains. While the 'wa_' prefix suggests WhatsApp context, the description itself provides no meaningful elaboration beyond the name.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines1/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides absolutely no guidance about when to use this tool versus alternatives. There are multiple sibling template tools (wa_template_delete, wa_template_delete_by_name, wa_template_edit, wa_template_get, wa_template_list), but the description offers no differentiation. It doesn't mention prerequisites, appropriate contexts, or when this tool should be preferred over others.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior1/5
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. 'Edit a template' implies a mutation operation but reveals nothing about permissions, side effects, error handling, or response format. For a tool with 3 parameters and no output schema, this lack of transparency is critical and inadequate.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise with just three words, front-loading the core action. There is no wasted verbiage or redundancy. While under-specified, it is structurally efficient and earns full marks for brevity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (3 parameters, mutation operation, no annotations, no output schema, and multiple sibling tools), the description is severely incomplete. It fails to address key contextual elements like what 'editing' entails, how it differs from creation or deletion, what the parameters do, or what to expect upon execution. This inadequacy hinders effective tool use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, meaning none of the 3 parameters (name, language, body) are documented in the schema. The description adds no information about parameter meanings, formats, or constraints. For example, it doesn't clarify if 'name' refers to an existing template name, what 'language' codes are valid, or what 'body' should contain. This leaves parameters entirely unexplained.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose2/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Edit a template' is a tautology that restates the tool name 'wa_template_edit' without adding meaningful context. It specifies the verb 'edit' and resource 'template' but lacks specificity about what aspects are editable or how this differs from sibling tools like wa_template_create or wa_template_update_profile. The purpose is clear at a basic level but fails to distinguish from alternatives.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines1/5
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 wa_template_create, wa_template_delete, wa_template_get, and wa_template_list, there is no indication of prerequisites, appropriate contexts, or exclusions. This leaves the agent without direction on tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior1/5
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. The description only states the action ('retrieve') without any information about permissions required, rate limits, error conditions, what data is returned, or whether it's a read-only operation. For a tool with no annotations, this leaves critical behavioral traits unspecified.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise with just three words, making it front-loaded and efficient. There's no wasted language or unnecessary elaboration, though this conciseness comes at the cost of completeness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has no annotations, no output schema, and 0% schema description coverage for 2 required parameters, the description is completely inadequate. It doesn't explain what the tool returns, how to use it properly, or provide any context beyond the basic action. For a retrieval tool in a WhatsApp API context with multiple sibling tools, this leaves too many gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description provides no information about parameters, while the input schema has 2 required parameters (wabaId and phoneNumber) with 0% schema description coverage. The description doesn't explain what these parameters represent, their format, or how they're used, failing to compensate for the complete lack of schema documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose2/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Retrieve a phone number' is a tautology that essentially restates the tool name 'wa_phone_retrieve'. While it indicates the verb 'retrieve' and resource 'phone number', it lacks specificity about what exactly is retrieved (e.g., details, settings, status) and doesn't distinguish it from sibling tools like 'wa_phone_retrieve_commerce_settings' or 'wa_phone_retrieve_profile' that retrieve specific aspects of phone numbers.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines1/5
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, context, or differentiate from sibling tools such as 'wa_phone_list' (which might list multiple numbers) or other retrieve tools for commerce settings or profiles. There's no indication of when this tool is appropriate or when to choose other options.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior1/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. 'Enqueue a message' suggests a queuing operation but doesn't disclose behavioral traits like whether it's asynchronous, requires authentication, has rate limits, or what happens on failure. It lacks critical details needed for safe and effective use, especially for a message-sending tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise with a single phrase 'Enqueue a message', which is front-loaded and wastes no words. It's appropriately sized for its minimal content, though this conciseness comes at the cost of completeness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of message-sending (implied by sibling wa_msg_send_directly), no annotations, no output schema, and 0% schema coverage, the description is completely inadequate. It doesn't explain what the tool does in context, how to use it, what parameters mean, or what to expect in return.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, with one parameter ('body') undocumented in both schema and description. The description adds no meaning beyond the schema—it doesn't explain what 'body' should contain, its format, or examples. For a single parameter with no schema documentation, this is a significant gap.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose2/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Enqueue a message' states a verb ('enqueue') and resource ('message'), but is vague about what type of message and to what system. It distinguishes from siblings like wa_msg_retrieve (retrieve vs enqueue) but not clearly from wa_msg_send_directly (enqueue vs send directly). The purpose is somewhat clear but lacks specificity about the WhatsApp context implied by the tool name.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use this tool versus alternatives like wa_msg_send_directly. The description implies it's for sending messages, but doesn't specify contexts, prerequisites, or exclusions. The sibling list suggests it's part of a WhatsApp toolset, but no usage context is provided in the description itself.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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. 'Retrieve' implies a read-only operation, but it doesn't specify whether authentication is needed, if there are rate limits, what happens on failure (e.g., missing template), or the format of the returned data. This leaves significant gaps in understanding the tool's behavior beyond the basic action.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise with just two words, 'Retrieve a template', which is front-loaded and wastes no space. However, this brevity comes at the cost of completeness, but as per scoring rules, conciseness is evaluated independently based on efficiency, which is high here.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (2 required parameters, no annotations, no output schema, and 0% schema description coverage), the description is completely inadequate. It doesn't explain what a template is in this context, how parameters are used, what the tool returns, or how it differs from siblings, leaving the agent with insufficient information to use the tool effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 2 required parameters (name, language) with 0% description coverage, meaning the schema provides no semantic information. The description 'Retrieve a template' adds no details about what these parameters represent (e.g., template identifier, language code), their formats, or constraints, failing to compensate for the schema's lack of documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose2/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Retrieve a template' is a tautology that essentially restates the tool name 'wa_template_get' with minimal added value. While it indicates the action (retrieve) and resource (template), it lacks specificity about what kind of template or what retrieval entails, and doesn't differentiate from sibling tools like 'wa_template_list' or 'wa_template_retrieve' (if that existed).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines1/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'wa_template_list' for listing templates or 'wa_template_retrieve' (implied by context), nor does it specify prerequisites or contexts for retrieval, leaving the agent with no usage direction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior1/5
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. 'List templates' implies a read-only operation but reveals nothing about permissions, rate limits, pagination, error handling, or output format. This leaves critical behavioral traits undocumented, making it inadequate 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise at two words, with zero wasted text. It is front-loaded and efficiently communicates the core action, though this brevity comes at the cost of completeness. Every word earns its place by directly stating the tool's function.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (2 required parameters, no annotations, no output schema), the description is severely incomplete. It lacks parameter explanations, behavioral context, usage guidelines, and output details, making it insufficient for an agent to understand how to properly invoke or interpret results from this tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, meaning parameters 'filter.name' and 'filter.language' are entirely undocumented in the schema. The description adds no information about these parameters—not their purpose, format, examples, or constraints. This fails to compensate for the schema gap, leaving parameters semantically opaque.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'List templates' clearly states the verb ('List') and resource ('templates'), making the basic purpose understandable. However, it lacks specificity about scope or differentiation from sibling tools like 'wa_template_get' (which presumably retrieves a single template), leaving the agent uncertain about when to choose one over the other.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. With siblings like 'wa_template_get' and 'wa_template_edit', the agent must infer usage from tool names alone, which is insufficient for reliable selection. No explicit when/when-not instructions 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.
Behavior2/5
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. 'Retrieve' implies a read-only operation, but it doesn't specify if this requires authentication, has rate limits, returns structured data, or handles errors. For a tool with no annotations, this minimal description leaves critical behavioral traits unaddressed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with no wasted words, making it front-loaded and easy to parse. However, it may be overly concise given the lack of context around 'WABA' and the parameter, slightly reducing clarity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (a retrieval operation with 1 parameter), no annotations, no output schema, and 0% schema description coverage, the description is incomplete. It doesn't explain what a WABA is, what the 'id' parameter entails, or what the tool returns, leaving significant gaps for an AI agent to use it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 1 parameter ('id') with 0% description coverage, meaning the schema provides no semantic information. The description does not explain what 'id' represents (e.g., a WABA identifier, format, or source), failing to compensate for the low schema coverage. This leaves the parameter's meaning ambiguous.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose2/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Retrieve a WABA' states a verb ('Retrieve') and resource ('WABA'), but 'WABA' is an acronym that may not be universally understood without context. It doesn't distinguish this tool from sibling retrieval tools like 'wa_phone_retrieve' or 'wa_template_get', which follow similar naming patterns. The purpose is somewhat clear but lacks specificity about what a WABA represents.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. With sibling tools like 'wa_business_list' (which likely lists multiple WABAs) and other retrieve tools, there's no indication of whether this is for fetching a single business by ID or how it differs from similar operations. The description offers no context for selection among retrieval tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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. 'Update' implies a mutation operation, but the description doesn't specify whether this requires special permissions, what happens to existing profile data, whether changes are reversible, or what the typical response looks like. It provides minimal behavioral context beyond the basic action.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise at just four words, which is efficient for a simple action. However, it's arguably too brief given the complexity of the operation (updating a profile with three parameters, one of which is completely undocumented). Every word earns its place, but more context would be helpful.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a mutation tool with three parameters (one completely undocumented as 'body'), no annotations, and no output schema, the description is inadequate. It doesn't explain what profile fields can be updated, what the 'body' parameter should contain, what permissions are required, or what the operation returns. The agent has insufficient information to use this tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the schema provides no parameter documentation. The description mentions 'phone number profile' but doesn't explain what the three parameters (wabaId, phoneNumber, body) represent or how they're used. The 'body' parameter is particularly opaque with no type specification. The description adds almost no semantic value beyond what's inferred from the tool name.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Update a phone number profile' clearly states the action (update) and resource (phone number profile), but it's vague about what specific aspects of the profile are updated. It distinguishes from siblings like wa_phone_retrieve_profile (retrieve) and wa_phone_update_commerce_settings (update commerce settings), but doesn't specify what distinguishes it from wa_phone_register or other update operations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. The description doesn't mention prerequisites, when this operation is appropriate, or what distinguishes it from similar tools like wa_phone_register or wa_phone_update_commerce_settings. 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.
Behavior2/5
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 but only states the action 'Retrieve a message'. It doesn't describe whether this is a read-only operation, what data is returned, potential errors, rate limits, or authentication needs, leaving 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description 'Retrieve a message' is extremely concise—a single phrase with no wasted words. It's front-loaded and efficiently communicates the core action, though this brevity contributes to its lack of detail in other dimensions.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity implied by sibling tools (e.g., messaging and business operations) and the absence of annotations and output schema, the description is incomplete. It fails to provide necessary context about what a 'message' entails, how retrieval works, or what the tool returns, making it inadequate for effective use by an AI agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
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 param details, which is appropriate, but it also doesn't compensate for any gaps since there are none. A baseline of 4 is applied as it meets the requirement for a tool with no parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose2/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Retrieve a message' is a tautology that essentially restates the tool name 'wa_msg_retrieve' without adding specificity. It doesn't clarify what type of message (e.g., WhatsApp message), from which context, or how retrieval works, leaving the purpose vague beyond the obvious.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 'wa_msg_send' or 'wa_business_retrieve'. The description lacks context about prerequisites, such as needing a message ID or specific permissions, and doesn't mention any exclusions or complementary tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden for behavioral disclosure. It states 'retrieve' implying a read-only operation, but doesn't clarify authentication needs, rate limits, error conditions, or what the profile contains. 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.
Conciseness5/5
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 retrieval operation and front-loads the essential action and target.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations, 0% schema coverage, no output schema, and multiple similar sibling tools, the description is incomplete. It doesn't explain what a 'phone number profile' entails, how it differs from other phone-related retrievals, or what to expect in return. More context is needed for effective tool use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so parameters 'wabaId' and 'phoneNumber' are completely undocumented in the schema. The description adds no meaning about what these parameters represent, their formats, or examples. It fails to compensate for the schema's lack of documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Retrieve a phone number profile' clearly states the action (retrieve) and target (phone number profile), making the purpose understandable. However, it doesn't differentiate from sibling tools like 'wa_phone_retrieve' or 'wa_phone_retrieve_commerce_settings', leaving ambiguity about what specific profile information is retrieved versus those other retrieval tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. With siblings like 'wa_phone_retrieve' and 'wa_phone_retrieve_commerce_settings', there's no indication whether this tool retrieves different profile data, is for specific contexts, or has prerequisites. The agent must infer usage from tool names alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. 'Mark message as read' implies a mutation (changing read status), but it doesn't disclose behavioral traits such as required permissions, whether it's idempotent, error handling, or side effects. This is a significant gap for a mutation tool with zero annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with zero waste—'Mark message as read' directly conveys the core action. It's appropriately sized and front-loaded, making it easy to parse without unnecessary elaboration.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's mutation nature, lack of annotations, no output schema, and incomplete parameter documentation, the description is insufficient. It doesn't cover return values, error cases, or operational context (e.g., how it interacts with other WhatsApp tools), making it incomplete for safe and effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 1 parameter with 0% description coverage, and the tool description adds no meaning beyond the schema. It doesn't explain what 'id' represents (e.g., message ID from retrieval), its format, or constraints. With low schema coverage, the description fails to compensate, leaving the parameter undocumented.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Mark message as read' clearly states the action (mark) and the resource (message) with a specific state change (as read). It distinguishes from siblings like wa_msg_retrieve or wa_msg_send by focusing on updating read status rather than retrieving or sending messages. However, it doesn't explicitly differentiate from all siblings (e.g., other update operations), keeping it at 4 instead of 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a message ID from retrieval), exclusions, or comparisons to other tools like wa_msg_retrieve for checking status. This lack of context leaves usage unclear beyond the basic action.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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. 'Register a phone number' implies a write operation, but it doesn't specify permissions required, whether it's idempotent, rate limits, or what happens on success/failure. This is inadequate for a mutation tool with zero annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with zero waste. It's appropriately sized and front-loaded, making it easy to scan. Every word earns its place by conveying the core action without fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
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 operation with 2 parameters), no annotations, no output schema, and 0% schema coverage, the description is incomplete. It lacks details on behavior, parameters, and expected outcomes, making it insufficient for reliable agent use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate by explaining parameters. It adds no meaning beyond the schema—it doesn't clarify what 'wabaId' or 'phoneNumber' represent, their formats, or examples. With 2 undocumented parameters, this is a significant gap.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Register a phone number' clearly states the action (register) and resource (phone number), which is specific and unambiguous. However, it doesn't differentiate from sibling tools like 'wa_phone_list' or 'wa_phone_retrieve', which handle listing or retrieving phone numbers rather than registering them.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. For example, it doesn't mention prerequisites like needing a WABA ID from 'wa_business_list' or 'wa_business_retrieve', or when to use 'wa_phone_update_profile' instead. This lack of context leaves usage unclear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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. 'Delete a template' implies a destructive operation but doesn't specify whether deletion is permanent, reversible, requires specific permissions, or has side effects. For a destructive 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is maximally concise with just three words. It's front-loaded with the essential action and resource, with zero wasted words or unnecessary elaboration.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given this is a destructive operation with 2 required parameters, 0% schema coverage, no annotations, and no output schema, the description is inadequate. It doesn't explain what parameters mean, what happens during deletion, or what to expect as a result. The context demands more completeness than provided.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate for undocumented parameters. The description mentions no parameters at all, leaving both 'name' and 'language' completely unexplained. This fails to add any meaning beyond what the bare schema provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Delete a template' clearly states the action (delete) and resource (template), making the purpose immediately understandable. It doesn't explicitly differentiate from sibling tools like 'wa_template_delete_by_name', but the verb+resource combination is specific enough for basic understanding.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 'wa_template_delete_by_name' and 'wa_template_edit' available, there's no indication of when this deletion method is appropriate versus other deletion or modification approaches.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 destructive action (delete) but doesn't mention permissions required, whether deletion is permanent/reversible, rate limits, error conditions, or what happens if the template doesn't exist. This is inadequate for a destructive operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise at just three words, front-loading the essential information with zero wasted text. Every word earns its place by specifying action, resource, and method.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a destructive tool with no annotations, 0% schema coverage, and no output schema, the description is insufficient. It doesn't cover behavioral aspects like safety, permissions, or response format, nor does it provide adequate parameter guidance despite the concise statement of purpose.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It mentions 'by name' which clarifies the single parameter's purpose, but doesn't explain name format, case sensitivity, validation rules, or provide examples. The parameter remains largely undocumented.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Delete templates by name' clearly states the action (delete) and target resource (templates), with the qualifier 'by name' indicating the deletion method. It distinguishes from the sibling 'wa_template_delete' which likely deletes by ID or other identifier, though this distinction isn't explicitly stated.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 'wa_template_delete' or other template management tools. The description doesn't mention prerequisites, constraints, or appropriate contexts for invocation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. 'List WABAs' implies a read-only operation but doesn't specify whether it returns all WABAs, supports pagination, requires authentication, or has rate limits. For a tool with zero annotation coverage, this leaves significant gaps in understanding its behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise ('List WABAs')—just two words that directly convey the core function. It's front-loaded with the verb and resource, leaving no wasted space or unnecessary elaboration.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (0 parameters, no output schema) and lack of annotations, the description is minimal but incomplete. It doesn't explain what WABAs are, the return format, or behavioral aspects like pagination, which are needed for an agent to use it effectively in context with sibling tools.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0 parameters with 100% coverage, meaning no parameters need documentation. The description doesn't add parameter details, which is appropriate here. A baseline of 4 is given since no parameters exist, and the description doesn't misleadingly suggest any.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'List WABAs' clearly states the action (list) and resource (WABAs), making the tool's purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'wa_phone_list' or 'wa_template_list' beyond the resource type, which prevents a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. With siblings like 'wa_business_retrieve' (likely for single WABA details) and 'wa_phone_list' (for phone numbers), there's no indication of context, prerequisites, or exclusions for this listing operation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. 'List phone numbers' implies a read-only operation but doesn't specify any behavioral traits such as pagination, sorting, filtering, rate limits, authentication requirements, or what happens if no phone numbers exist. This leaves significant gaps in understanding how the tool behaves in practice.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise ('List phone numbers') and front-loaded, with no wasted words. It directly conveys the core action and resource in a minimal format, making it efficient and easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of listing operations (which often involve pagination, filtering, or sorting) and the lack of annotations and output schema, the description is incomplete. It doesn't address what the output looks like, how results are structured, or any constraints on the listing process, leaving the agent with insufficient context to use the tool effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters, and the input schema has 100% description coverage (though empty). The description doesn't need to add parameter semantics since there are none, so it meets the baseline of 4 for tools with no parameters, as it doesn't introduce confusion or omissions regarding inputs.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'List phone numbers' clearly states the verb ('List') and resource ('phone numbers'), making the tool's purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'wa_phone_retrieve' or 'wa_phone_retrieve_profile', which might also involve phone number retrieval in different contexts.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 'wa_phone_retrieve' (which likely retrieves a specific phone number) and 'wa_phone_retrieve_profile' (which might get profile details), there's no indication of when listing is preferred over retrieving specific items or what context triggers its use.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![ycloud-whatsapp-mcp-server MCP server](https://glama.ai/mcp/servers/YCloud-Developers/ycloud-whatsapp-mcp-server/badges/card.svg)](https://glama.ai/mcp/servers/YCloud-Developers/ycloud-whatsapp-mcp-server)

Score Badge

Copy to your README.md:

[![ycloud-whatsapp-mcp-server MCP server](https://glama.ai/mcp/servers/YCloud-Developers/ycloud-whatsapp-mcp-server/badges/score.svg)](https://glama.ai/mcp/servers/YCloud-Developers/ycloud-whatsapp-mcp-server)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/YCloud-Developers/ycloud-whatsapp-mcp-server'

If you have feedback or need assistance with the MCP directory API, please join our Discord server