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

With no annotations, the description carries the full behavioral burden. It discloses that the tool writes a local file and returns success status plus a file path, but it does not mention permissions, whether existing files are overwritten, or how failures are surfaced beyond a status flag.

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 first sentence front-loads the action and outcome, and the Args/Returns sections are compact. The formatting is slightly formulaic but no sentence is wasted.

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?

The tool has two required parameters, no annotations, and an output schema. The description covers purpose, both parameters, and the return shape, which is sufficient for an agent to select and invoke it correctly. It lacks only minor operational details like file overwrite behavior or permissions.

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

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

Schema description coverage is 0%, so the description must compensate. It documents both required parameters with their meaning: message_id identifies the message containing the media, and chat_jid identifies the containing chat. It does not specify JID or message-ID formats, but it covers all 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 states a specific verb (Download) and resource (media from a WhatsApp message) plus the direct outcome (local file path). This clearly distinguishes it from siblings like send_file, which moves data in the opposite direction.

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?

Usage is implied by the action and the WhatsApp-message scope, but there is no explicit guidance on when to use this versus alternatives such as get_message_context or list_messages. No exclusions or prerequisites are stated.

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

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

No annotations exist, so the description carries the full behavioral burden, yet it only says metadata is returned. It does not disclose what happens if the JID is unknown, whether the WhatsApp connection must be active, or how include_last_message changes the payload. The default value it mentions is already in the schema.

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

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

The one-line purpose is front-loaded and the Args section is compact. It is efficiently sized, though the Args lines mostly restate the property names.

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?

With only two parameters and an output schema, the definition covers enough to invoke the tool, but it omits any error or precondition context and does not route the agent away from overlapping sibling tools.

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

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

Schema description coverage is 0%, so the Args block does add meaning: chat_jid identifies the target chat and include_last_message toggles inclusion of the most recent message. However, 'JID' is never explained in format terms (e.g. user@server) and what 'last message' includes is left ambiguous, so it only partially compensates for the schema gap.

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

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

States a specific verb and resource: 'Get WhatsApp chat metadata by JID.' An agent can tell this retrieves a single chat's metadata rather than listing chats or messages. It does not explicitly distinguish itself from near-siblings like get_direct_chat_by_contact or list_chats, which keeps it below 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?

There is no guidance on when to use this versus list_chats, get_direct_chat_by_contact, or get_contact_chats. The only contextual hint is that it needs a JID, which implies you must already know the chat identifier, but this is never stated as a precondition.

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 does disclose useful behavior beyond the schema — automatic identifier-type detection and a 'resolved' status field — but never says what happens when no contact matches, whether it can create records, or whether any permissions are needed.

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 core purpose and the auto-detection behavior are front-loaded in the first two sentences, and the Args block earns its space by supplying examples the schema lacks. The docstring-style formatting is slightly verbose but not wasteful.

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?

An output schema exists, so the Returns section is redundant but harmless. The real gap is behavioral: for a lookup tool the not-found path matters, and the three overlapping optional parameters create resolution ambiguity that the description doesn't resolve.

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 coverage is 0%, so the description must compensate, and it largely does: it gives concrete examples for phone number, LID, phone JID, and LID JID, and explains that phone_number and phone are backward-compatible aliases for identifier. It does not state that all three are optional/nullable or which one wins when more than one is supplied.

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?

States a specific verb and resource ('look up a WhatsApp contact') and scopes it to exact identifiers (phone number, LID, full JID), which implicitly distinguishes it from the sibling search_contacts. It never names the sibling or states the distinction explicitly, so it stops short of 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?

Usage is implied by the identifier-based framing: use this when you already have an exact identifier. There is no explicit when-to-use / when-not guidance and no reference to search_contacts for fuzzy or name-based lookups, even though that sibling exists and is the obvious alternative.

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 exist, so the description carries the full burden; it implies a read-only retrieval and discloses the defaults for limit (20) and page (0). It does not state ordering, whether group chats count as "involving" the contact, or whether pagination past the last page errors or returns empty.

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?

One clear lead sentence followed by a compact args list; nothing is padded or redundant. The lead sentence is front-loaded, though it lacks the routing information that would make the brevity fully efficient.

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

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

The output schema means return values needn't be described, and all three inputs are covered, so the basics are present. For a lookup tool with 0% schema coverage and no annotations, however, the ambiguous scope of "involving" leaves the agent unsure what a result set actually contains.

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

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

Schema description coverage is 0%, but the args block documents all three parameters, including the required JID and the pagination defaults, compensating for the schema gap. It falls short of a 5 because it never explains the JID format or what happens when limit is exceeded.

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

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

The description states a specific verb and resource ("Get all WhatsApp chats involving the contact") and scopes results to a single contact's JID. This implicitly separates it from list_chats and get_chat, but it never names those siblings, so an agent must infer the distinction from the tool name alone.

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?

There is no guidance on when to use this versus get_direct_chat_by_contact, list_chats, or get_last_interaction, all of which overlap in scope. The only hint is the word "involving," which is never explained, so an agent gets no explicit selection criteria.

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

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

No annotations are provided, so the description carries the burden; the verb 'Get' does imply a read-only lookup and 'chat metadata' hints at the return shape. It does not say what happens when no chat exists for the number, whether the match is exact, or whether any auth scope is required.

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?

Short and front-loaded, with the key operation in the first clause. The 'Args:' block is boilerplate that adds nothing over the schema but is not harmful.

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?

An output schema exists, so return values need not be explained, and a single-parameter read tool is inherently simple. Still, the one thing an agent could get wrong, the phone number format, is left unspecified.

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

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

Schema description coverage is 0%, so the description must compensate and it largely restates the field name ('The phone number to search for'). It never specifies the expected format (country code, E.164, digits only), which is the key ambiguity for a phone-number lookup.

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?

States a specific verb and resource ('Get WhatsApp chat metadata') and scopes it by sender phone number, which distinguishes it from the broader list_chats and the id-based get_chat. It stops short of naming those siblings explicitly.

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?

There is no guidance on when to use this versus list_chats, search_contacts, or get_chat, and no prerequisites or failure conditions are mentioned. The agent must infer from the name that this is the lookup-by-phone-number route.

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 behavioral burden. It does disclose a useful edge case ('empty dict if not found'), implying a read-only lookup, but it says nothing about permissions, whether sent and received messages are both considered, or how media-only messages are handled.

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 core purpose is front-loaded in the first sentence, followed by a conventional Args/Returns block. The structure is efficient, though slightly verbose for a one-parameter 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?

An output schema already exists, so the description's Returns block is largely redundant, and the remaining gaps are behavioral: nothing about ordering semantics, whether outgoing messages count, or authorization requirements. Adequate to invoke, but incomplete for a no-annotation tool.

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

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

The single parameter is at 0% schema description coverage, so the description must compensate. It states jid is 'the JID of the contact to search for,' which gives meaning but no format guidance (e.g., a phone-number-based JID or group JID) to help the agent construct a valid 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 opens with a specific verb and resource: 'Get the most recent WhatsApp message involving the contact.' This clearly delimits the result to a single, newest message, distinguishing it from list-style siblings like list_messages. It does not explicitly name an alternative, but the singleton scope makes the intent unambiguous.

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

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

Usage is implied rather than stated — an agent can infer this is a quick 'latest message' lookup rather than a search or history tool. There is no explicit guidance on when to prefer it over list_messages or get_message_context, and no prerequisites or exclusions are given.

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

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

No annotations are provided, so the description carries the full burden. 'Get' implies a read-only operation and the before/after defaults hint at the bounded window behavior, which is useful. It doesn't state what happens for an unknown message_id, ordering of returned messages, or any limits on before/after values.

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?

A single front-loaded summary sentence followed by a compact Args list; every line adds information (including defaults and the conditional chat_jid rule) 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?

An output schema exists, so return-value explanation isn't needed, and all four parameters are documented with defaults and conditionality. The only gaps are edge-case behavior (unknown/missing message, window ordering) for a tool whose read-only nature is only implied.

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

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

Schema description coverage is 0%, so the description must supply all parameter meaning — and it does, explaining message_id, the before/after counts with their default of 5, and the conditional requirement on chat_jid. It doesn't specify valid ranges for before/after, which would be the final increment.

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?

States a specific verb and resource: 'Get context around a specific WhatsApp message', which is clearly a windowed read around one message. This is distinguishable from sibling list_messages by the 'around a specific message' framing, though the description doesn't name the sibling as an alternative.

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?

Usage is implied by the resource ('context around a message'), and the chat_jid arg note gives a conditional usage hint ('required when its ID occurs in multiple chats'). However, there is no explicit when-to-use-this vs list_messages guidance and no stated preconditions for resolving a message_id.

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

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

No annotations exist, so the description carries the full behavioral burden. It adds useful operational facts — default limit 50 with a 200 cap, default page 0 pagination, and default sorting by last_active — but says nothing about read-only nature explicitly, permissions/auth requirements, or rate limits. Adequate but incomplete for a zero-annotation 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?

Front-loaded with a one-line purpose followed by a compact, scannable per-parameter list. The 'Args:' scaffold is boilerplate but every line carries information, so there is minimal 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?

An output schema exists, so return values needn't be explained, and parameters are fully covered. What remains missing is sibling routing and any permission or safety context for a tool with no annotations — enough gaps to keep it at minimum-viable-plus rather than 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 0%, so the description must compensate, and it largely does: all five parameters are documented with defaults, the limit ceiling, and the two valid sort_by values (which the schema does not enumerate via enum). It is missing only the type/nullability nuance for query.

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?

States a specific verb and resource (get WhatsApp chats) and hints at filtering criteria. However, it never distinguishes this from siblings like get_chat, get_contact_chats, or list_messages, so the agent must infer the boundary from the name alone.

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?

There is no when-to-use or when-not-to-use guidance and no mention of alternatives. With siblings such as get_contact_chats (chats for a specific contact) and get_chat (a single chat) present, the description should say which one to pick when scoping to one contact or one chat.

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 the full burden and does well: it discloses defaults (limit 50, max 500, page 0, include_context True, 1 before/after), sort semantics, and the sender_display output shape. It omits that this is a read-only/non-destructive operation and says nothing about permissions or rate limits, which is the main remaining gap.

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

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

A front-loaded one-line purpose followed by a compact Args block where every line adds concrete information; the sender_display note is placed early where it is useful. Only minor redundancy between include_context and the context_before/after defaults.

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?

Eleven optional parameters are all explained, defaults are stated, and an output schema exists so return values need not be enumerated. Missing only operational context (read-only nature, pagination totals) which would fully close the loop.

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 coverage is 0%, so the description must compensate entirely, and it does: all 11 parameters get meaning, format, and examples (ISO-8601 dates, E.164-style phone, chat JID forms, sort_by enumerations) plus defaults and the max cap on limit. This is meaningfully richer than the bare schema types.

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

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

States a specific verb and resource ("Get WhatsApp messages") plus the notion of filtering by criteria and optionally pulling context. It is clear what the tool returns, but it never contrasts itself with the close sibling get_message_context, which also deals with surrounding 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?

Usage is only implied: the parameter list suggests filtering by sender, chat, date, or query, and include_context/context_before/context_after imply context retrieval. There is no explicit when-to-use statement and no guidance to prefer get_message_context or list_chats under any condition.

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, and it discloses almost nothing behavioral: no statement on partial vs exact matching, case sensitivity, result limits, or ordering. That 'search' is non-destructive is inferable from the verb but not stated, and nothing warns about ambiguous matches.

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 core sentence is front-loaded and unambiguous, and the Args block is short enough not to waste space. Slight redundancy in restating the parameter name, but every line adds a bit of meaning.

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 one-parameter read tool with an output schema, the basics are covered, so return values need no explanation. What is missing is search-specific behavior: whether multiple contacts can come back, how results are ordered, and what an empty result looks like.

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

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

Schema description coverage is 0% (the property has only the title 'Query'), so the description must compensate, and it does by defining the term as matching against contact names or phone numbers. It still omits match semantics (substring, prefix, normalized phone format), which is the one thing an agent would most need.

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?

States a specific verb (search) and resource (WhatsApp contacts) plus the matching keys (name or phone number), which distinguishes it from get_contact in the sibling list. It stops short of explicitly naming that sibling or noting that results may be multiple.

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?

Usage is only implied: an agent can infer this is the lookup path when it lacks a contact ID, versus get_contact for direct retrieval. There is no explicit 'use this when / use X instead' routing, no mention of what happens when no match is found.

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 the burden and does add meaningful behavioral context: automatic conversion to Opus .ogg if needed, the ffmpeg dependency, and the return shape. It does not disclose permission/auth requirements or the irreversibility of sending a WhatsApp message, which would be needed for a full 5.

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 purpose and the sibling fallback are front-loaded in the first two sentences, followed by compact Args/Returns sections. Every sentence adds information; there is no redundant restatement of the tool name.

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 two-parameter send tool with no annotations but an output schema, the description covers the critical call details: addressing formats, path expectations, auto-conversion, and the ffmpeg fallback. Missing authorization/side-effect notes keep it from being fully complete.

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

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

Schema description coverage is 0%, so the description must compensate. It documents both parameters well: recipient format (country code without symbols, or JID examples like '123456789@s.whatsapp.net' and '123456789@g.us') and media_path as an absolute path with conversion behavior. It could still specify supported input formats or relative-path behavior for a 5.

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

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

States a specific verb and resource ('Send any audio file as a WhatsApp audio message') and implicitly distinguishes itself from send_file by naming that sibling as the fallback when ffmpeg is missing. An agent can tell this is the audio-message sending tool, not generic file or text sending.

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?

Gives clear when-to-use guidance for the most relevant alternative: 'If ffmpeg isn't installed, use send_file instead.' It also clarifies group-message addressing via JID. It does not explicitly contrast with send_message for text, but the audio-vs-text distinction is implicit in the purpose.

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

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

With no annotations, the description carries the full burden and does disclose supported media types, recipient formats, absolute-path requirement, and a return shape. Still, it omits important send-side behavior such as authentication needs, file size limits, rate limits, and failure handling.

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

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

The description is front-loaded and organized with Args and Returns sections. The Returns section is somewhat redundant because an output schema exists, and the recipient explanation is a bit verbose, but there is little 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 simple two-parameter send tool with an output schema, the description gives enough parameter detail to invoke it correctly. The main remaining gap is behavioral context around authentication, limits, and failure modes, which is not covered by annotations.

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

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

Schema description coverage is 0%, so the description must compensate, and it does: recipient is explained as either a country-code phone number without symbols or a JID with examples, and media_path is described as an absolute path with supported file categories.

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

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

The description states a clear verb and resource: sending a file via WhatsApp, with supported media types listed. It does not explicitly distinguish this tool from the sibling send_audio_message, even though audio is mentioned, so it falls short of 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?

It gives a concrete recipient rule for group messages: use the JID. However, it does not say when to use send_file rather than send_message or send_audio_message, nor does it state any 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?

With no annotations, the description carries the full burden. It discloses that sending is immediate and returns a success status, but says nothing about required auth, rate limits, whether the message is recallable, or what a failure looks like beyond a "status message"

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?

Front-loaded with the core action, then scoped parameter detail. The "Args:"/"Returns:" boilerplate is slightly redundant given a structured schema and output schema exist, but overall it is tight.

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?

An output schema exists, so the Returns block is superfluous, and the critical gaps are behavioral: no mention of authentication requirements, delivery semantics, or error conditions for a side-effecting messaging tool with zero annotation coverage.

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

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

Schema coverage is 0%, so the description must compensate — and it does, spelling out the recipient format in detail (country code, no '+' or symbols, JID forms for direct and group chats). The message parameter is left as just "message text", which is self-evident but not enriched.

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?

States a specific verb and resource ("Send a WhatsApp message") and narrows it to text messages by contrasting implicitly with siblings send_file and send_audio_message. The scope is unmistakable without opening the schema.

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?

It provides a conditional routing hint for group chats ("use the JID"), but never states when to choose this tool over send_file or send_audio_message, nor any prerequisites such as needing an authenticated session or known contact.

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