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

With no annotations, the description carries the full behavioral burden. It usefully discloses the answered-only default and the mandatory confirmation flag, which implies a guarded destructive operation. However, it stops short of stating what is actually cleared, whether the action is reversible, or what happens when onlyAnswered is false.

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?

Three short fragments with no filler, front-loaded with the core action. It is appropriately terse for a two-boolean-parameter tool, though the brevity leaves some explanatory gaps.

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

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

For a destructive queue-clearing operation, the description is incomplete: there is no output schema, no statement of irreversibility, no explanation of what the AI queue represents, and no clarity on the effect of onlyAnswered=false. An agent can likely invoke it, but reliability and safety understanding are limited.

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 adds meaning by associating 'answered-only' with the onlyAnswered parameter and asserting that confirm must be true, which goes beyond the schema's default. Still, it does not explain the effect of confirm=false or fully define what 'answered-only' means in the queue context.

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

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

The description states a specific verb and resource: 'Bersihkan antrean AI' (Clear AI queue). This is not a tautology and identifies a unique resource distinct from sibling tools like ai_inbox, ai_reply, and ai_config, though it does not explicitly contrast with them.

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

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

No guidance is provided about when to use this tool versus alternatives or what contextual conditions call for it. 'Requires confirm=true' is a parameter constraint rather than usage context, and there are no exclusions, prerequisites, or alternative routing.

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 present, so the description carries the full burden of behavioral disclosure. The verb 'view' implies a non-mutating read operation, but the description does not explicitly state that it has no side effects, whether it requires authentication, or what the response structure looks like. This is a significant gap for a tool with zero annotation support.

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

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

The description is a single concise sentence that front-loads the verb and resource, then lists the config items. No wasted words, and it effectively conveys the tool's scope in a compact form.

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 no-parameter config viewer, the description is largely complete: it names the specific config attributes the tool will show. The absence of an output schema is offset by the explicit list of fields, and the low complexity means the agent has enough information to use it correctly.

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

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

With zero parameters, the description has no need to explain parameter semantics. The schema is empty and fully covers the parameter surface, so a baseline of 4 is appropriate.

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

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

The description uses a clear verb 'Lihat config' (view config) with a specific resource (AI config) and lists the fields it covers (prefix, allowlist, react, cooldown, queue count). It implicitly distinguishes itself from sibling action tools like ai_reply and ai_clear, though it does not explicitly name alternatives.

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

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

The description provides no guidance on when to use this tool versus siblings like ai_inbox or ai_reply. It simply states what it does, leaving the agent to infer that it is for checking config, with no explicit conditions, exclusions, or alternatives.

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 behavioral disclosure burden. It does state that the tool is a queue meant to be answered by the agent and that it should be polled each turn, which is useful. However, it does not disclose whether polling consumes items, what side effects occur, or how 'unanswered' is determined.

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

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

The description is extremely short but every phrase earns its place: it defines the resource, connects it to the agent's task, and gives explicit polling cadence. There is no redundancy or filler.

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 poll tool with two optional parameters and no output schema, the description gives enough to understand the high-level purpose and invocation cadence. However, it omits the expected return shape and the semantics of onlyUnanswered, which an agent would benefit from knowing before calling.

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

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

Schema description coverage is 0%, and the description adds no information about limit or onlyUnanswered. The parameter names are somewhat self-explanatory, but the description fails to compensate for the schema gap, especially the meaning and default behavior of onlyUnanswered.

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

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

The description clearly identifies the tool as a pollable queue of WhatsApp prompts waiting for the agent to answer. The verb 'Poll' plus the resource 'antrean prompt /Wa.p' makes the core action explicit, and it distinguishes this from sibling tools like list_messages or ai_reply.

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

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

The instruction 'Poll ini tiap giliran' explicitly tells the agent when to use this tool: every turn. It does not explicitly state when not to use it or name alternatives, but for a polling tool the cadence guidance is strong and actionable.

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 behavioral burden and does so well: it discloses the side effects (send + mark answered), the confirm=true guardrail, and the 2s delay between sends. It does not cover reversibility or error behavior, but the core safety-relevant behavior is surfaced.

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 compact and front-loaded: purpose first, followed by side effect, prerequisite, and timing constraint in a single breath. No filler, though the unexplained 'Wa.p' token slightly hurts clarity.

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

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

It captures the essential flow, the confirm guardrail, and the rate-limit behavior, which is a solid amount of context given no annotations. But with no output schema, the agent is still missing expected return values, the failure mode when confirm is false, and what exactly 'answered' means in the queue state.

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 50%, so the baseline is 3. The description adds one useful parameter-level fact—confirm must be true, overriding the schema's default false—and implies the role of answer. It does not clarify the answer payload format or go beyond the schema's 'from ai_inbox' hints for chatJid/messageId.

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 action ('Jawab antrean' – answer the queue) and its concrete effects: send to the original chat and mark as answered. This distinguishes it from generic send_message, though the cryptic 'Wa.p' adds a small amount of ambiguity.

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

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

It gives a clear prerequisite ('Requires confirm=true') and implies this tool is for queued inbox replies. However, it never explicitly contrasts it with siblings like send_message or states when not to use it, leaving the routing decision mostly to inference.

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 genuine side effect — the QR is 'also printed on stderr' — which is useful because agents may otherwise rely only on the return value. However, it does not reveal other behavioral traits such as whether a new pairing session is initiated, whether QRs expire, or what happens when already authenticated.

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?

Two short sentences with no filler. The first delivers the core action plus the stderr side-effect; the second gives the human-action follow-through. Every word earns its place and the key content is front-loaded.

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

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

For a zero-parameter utility with no annotations and no output schema, the description is largely sufficient: it names the return value (the QR), the side channel (stderr), and the expected downstream user action. The only minor gap is that it never states the return format of the QR or failure behavior, but the tool's simplicity keeps this from being a significant omission.

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

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

The tool has zero parameters and 100% schema coverage, so the description need not document inputs. 'Get the latest' adds the meaningful semantic that the tool returns the most recent QR rather than generating a fresh session, which is the only invocation-relevant detail an agent needs when there are no arguments.

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 the latest WhatsApp pairing QR.' It clearly identifies what the tool produces and adds the user-facing purpose ('Scan with WhatsApp > Linked Devices'), which removes any ambiguity against the sibling list — no other sibling is about pairing or authentication.

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

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

The context of use is implied: this tool is for obtaining a QR to pair a new WhatsApp-linked device, reinforced by the scanning instruction. However, there is no explicit statement of when to use it versus alternatives, when not to use it, or any prerequisite such as being in an unauthenticated state — the guidance is present but only by implication.

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?

There are no annotations, so the description carries the full burden. It discloses the two output components (connection state, JID) which implies a read-only status operation, but it doesn't mention error behavior, authentication requirements, or whether the tool can be called regardless of connection state. For a simple status getter this is adequate but thin.

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

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

The description is extremely short and free of filler; every word contributes. It is a fragment rather than a full sentence, but for a zero-parameter status tool this brevity is effective.

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 is trivial in complexity: no parameters, no output schema, and the description states the return values. It doesn't cover edge cases or usage restrictions, but for a status read with no inputs the core information is present.

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

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

The tool takes no parameters, so there is nothing to document. The baseline of 4 applies.

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 names the specific resource (WhatsApp connection state and logged-in JID) and clearly implies a read/status operation. It distinguishes itself from siblings like ping or auth_qr by specifying exact data returned, though it lacks an explicit verb.

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

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

No guidance is given on when to prefer this tool over sibling tools such as ping, doctor, or auth_qr. There is no stated context, prerequisite, or 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?

There are no annotations, so the description carries the burden. It does disclose a key behavioral guardrail ('Requires confirm=true'), which is important for a destructive operation； however, it does not state irreversibility, error behavior if confirm is false, or consequences of deleting. This is moderate disclosure for a delete operation.

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

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

The description is extremely concise, with two short sentences that deliver the core action, scope, message-ID mechanism, and confirmation requirement. No filler or redundant phrases.

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 delete tool, the description covers the essential invocation details: target, scope, message ID, and confirmation. However, it lacks clarity on output/return behavior and edge cases (e.g., invalid/non-owned message ID), and there is no output schema to provide that context.

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

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

Schema coverage is 50% — messageId is documented but confirm is not. The description compensates by explicitly stating confirm=true is required, giving semantic meaning to the previously undocumented confirm parameter. This is valuable beyond the schema.

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

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

The description states a clear action ('Hapus Status/story' = delete status/story), specifies the target ('milik sendiri' = own only), and identifies the input mechanism ('via message id'). This clearly separates it from sibling tools like post_status and list_status, which create and read statuses respectively.

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

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

The description implies usage context: delete your own status/story using a message ID, and it explicitly requires confirm=true. However, it does not explicitly contrast with alternatives or state exclusions beyond 'own', so guidance is mostly implicit.

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 of behavioral disclosure. It names the diagnostic areas and 'Diagnostik' implies a read-only check, but it does not describe the output, side effects, credential sensitivity, or failure behavior. This is thin for a tool with no annotations and no output schema.

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

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

The description is compact and front-loaded with the core purpose, with no filler words. It is slightly cryptic due to abbreviated terms like 'creds' and 'antrean AI', but every listed item contributes to the diagnostic scope.

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

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

For a zero-parameter tool, invocation is straightforward and the listed components give enough context to select it. However, since there is no output schema and no annotation coverage, the description should at least hint at what a diagnostic result looks like; it currently does not.

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

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

The schema has zero parameters, so there is nothing for the description to clarify. The baseline of 4 applies because no parameter documentation is needed.

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

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

The description states the diagnostic scope explicitly: connection, credentials, store, version, and AI queue. It identifies the resource (WA) and is readily distinguishable from narrower siblings like connection_status or ai_config, though it never explicitly frames itself as the aggregate health-check tool.

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

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

No guidance is given about when to use this tool versus siblings such as connection_status, ping, or ai_config. The reader must infer that 'doctor' is for combined diagnostics, but the description never states this or rules out alternatives.

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 signals a read-only lookup via 'Check' and names fetchStatus, but it does not disclose what the response looks like, whether it can return empty results, error behavior, or any authorization requirements.

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?

Two short sentences, front-loaded with the purpose and an actionable input hint. No filler or redundant restructuring of the schema.

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 is simple and its schema fully documents the parameter, but with no output schema and no annotations the description should say more about expected return values and edge cases. It is usable but leaves gaps an agent must infer.

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

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

The schema already documents the single jids parameter with format examples and min/max constraints (100% coverage). The description only repeats that phone numbers or JIDs are accepted, so it adds little beyond the schema.

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

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

The description identifies a specific verb ('Check') and resource ('contact About/status text') and even names the underlying operation ('fetchStatus'). It is clear, but it does not explicitly distinguish itself from sibling list_status, 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: call this when you need a contact's About/status text, supplying phone numbers or JIDs. However, there is no explicit when-to-use/when-not-to-use guidance or comparison with alternatives such as list_status, post_status, or delete_status.

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 disclosure burden, and it does disclose the irreversible by-bot nature of the action. However, it does not explain the effect on the bot's membership, whether any permissions are needed, or what the response or error behavior looks like.

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

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

Two short, front-loaded sentences with no filler. The core purpose comes first, followed by the conditional requirement and the consequence, so an agent can parse the constraints quickly.

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

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

For a simple two-parameter action, the description covers the main decision points: purpose, mandatory confirmation, and irreversibility. It is not fully complete because jid is not semantically defined and there is no indication of return values or failure states, but the essential call constraints are present.

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 adds critical meaning to confirm (must be true despite its schema default of false), but it never explains that jid is the group identifier or what format is expected, leaving an essential parameter under-specified.

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 uses a specific verb-resource pair, 'Leave a group,' immediately identifying the action and target. It distinguishes the tool from sibling read-only group tools like group_metadata and list_groups, and no sibling overlaps with leaving a group.

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 explicitly states a precondition ('Requires confirm=true') and a key consequence ('Cannot be undone by bot'). It does not explicitly name alternatives or when-not-to-use, but no sibling offers a leave capability, so the conditional guidance is sufficient.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It discloses the cache fallback behavior, which is useful, and implies a live query nature. However, it does not state whether the operation is read-only, what exactly 'participating groups' means, or what the output structure looks like. The disclosed info is partial but not misleading.

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

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

The description is a single sentence, highly concise, and front-loaded with the primary action ('List all participating groups') before the secondary detail (cache fallback). Every word earns its place, and there is no redundancy.

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

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

Given the simplicity (0 parameters, no output schema), the description provides the core purpose and a behavioral detail. However, it omits clarification on what 'participating groups' means and the format of the output, and it does not address how this differs from list_groups. For a simple list tool, it is adequate but leaves some ambiguity that could affect correct invocation.

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

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

The tool has zero parameters, so there is no schema information to describe. The baseline for zero parameters is 4, and the description does not need to explain any parameters. No additional parameter semantics are required.

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

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

The description clearly states the verb 'List' and the resource 'all participating groups' with live names (subject, size). It conveys the core action and scope, but does not explicitly differentiate from sibling tools like list_groups, which also lists groups. The mention of 'live' hints at freshness but doesn't contrast it with the 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?

The description mentions fallback to cache when offline, which is a behavioral condition but not a usage guideline. It does not state when to prefer this tool over list_groups or other group-related tools, nor any exclusions or prerequisites. An agent receives no guidance on selecting this tool from among its siblings.

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

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

No annotations are provided, so the description carries the full burden. It says 'Check' which implies a read-only operation, but it does not disclose whether this is safe/idempotent, whether it requires authentication, or what happens if the group doesn't exist. For a tool with no annotations, this is a notable gap.

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

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

The description is a single short sentence that front-loads the action and lists the covered aspects. It is efficient and easy to parse, though it could be slightly more explicit about usage context.

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 no annotations and no output schema, the description must explain behavior and return value expectations. It lists what is checked but not what the response looks like, whether it can fail, or any side effects. For a simple read tool this is borderline adequate, but the lack of any behavioral detail makes it incomplete.

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

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

Schema coverage is 100% and the single parameter 'jid' is described with an example format. The description adds the context that the jid refers to a group and that the tool returns metadata about it, but it doesn't add much beyond the schema. Baseline 3 is appropriate.

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

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

The description states a specific verb ('Check') and resource ('one group'), and enumerates the aspects it covers: subject, participants, admins, timestamps. This is clear enough to distinguish it from sibling tools like group_list_live or group_leave, though it doesn't explicitly name a sibling 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?

The description implies usage: call this when you need metadata about a single group. It does not explicitly state when not to use it or mention alternatives like group_list_live for listing groups, but the scope is reasonably clear from the wording.

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 behavioral disclosure burden. 'Panduan pakai' strongly implies an informational, read-only help resource, but the description does not explicitly state that it returns static documentation or performs no WhatsApp actions. This is adequate but not fully explicit.

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

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

The description is a single, compact sentence that front-loads the tool's purpose and lists the key content categories. Every word earns its place, and there is no unnecessary detail.

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

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

For a zero-parameter help tool, the description is largely complete: it says what the tool is about and which topics it covers. It does not describe the exact return format, but no output schema exists and the tool's nature makes the output predictable.

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

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

The tool has zero parameters and an empty input schema, so the baseline is 4. There is no parameter information to add, and the description appropriately focuses on the tool's purpose rather than nonexistent arguments.

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 identifies the tool as a usage guide for whatsapp-mcp-free and lists the covered areas: tools, /Wa.p, anti-ban, and troubleshooting. This clearly distinguishes it from the operation-focused sibling tools, though it lacks an explicit imperative verb.

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

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

The description implies this tool is for getting guidance and troubleshooting, but it does not explicitly state when to choose help over a sibling tool or when not to use it. The context is understandable, yet no exclusions or alternative routing are provided.

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

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

No annotations are provided, so the description carries the full behavioral disclosure burden. It implies a read-only listing and states the ordering, but it does not disclose the return shape, whether group chats or newsletters are included, pagination behavior, or any authentication or availability caveats.

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

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

The description is a single short sentence with no filler. The action is front-loaded and the most important qualifier, sorting by recent activity, is included without unnecessary detail.

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 no output schema and no annotations, the description should do more to clarify what a 'chat' is, what fields are returned, and how this differs from other list tools. The provided text is minimally adequate for a simple call but leaves key context to inference.

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

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

The input schema fully documents the single optional 'limit' parameter with default, minimum, and maximum, so the practical gap is small. However, with 0% schema description coverage, the description adds no meaning about parameters and does not compensate for its absence.

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 uses a clear verb ('List'), a specific resource ('chats'), and adds a useful qualifier ('sorted by recent activity'). It is distinguishable from sibling tools like list_messages and list_status by resource name, though it does not explicitly define what counts as a chat or differentiate itself from list_groups.

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 tool versus list_groups, list_messages, list_newsletters, or search_messages. The description states only what the tool does, not the conditions under which it should be selected.

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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It only says 'List WhatsApp groups only' and does not explain authentication needs, output format, pagination, or whether any connection/auth state 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?

The description is extremely concise, front-loaded, and contains no filler. Every word adds information, especially 'only', which clarifies scope.

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

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

For a tool with no annotations and no output schema, the description leaves too much unstated. It covers the basic resource and action but omits operational context such as prerequisites, return behavior, and how the limit parameter affects results.

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

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

The schema has no description for the 'limit' parameter, and the description adds nothing about it. The agent must rely on the parameter name and schema constraints to infer that limit controls the number of groups returned.

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 action ('List') and resource ('WhatsApp groups'), and the word 'only' distinguishes it from sibling tools like list_chats and list_newsletters. An agent can immediately understand what this tool is for.

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

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

The word 'only' implies this tool should be used when groups are the target rather than chats or newsletters, but there is no explicit when-to-use guidance or named alternatives. Usage context is inferred rather than stated.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It implies a read-only listing operation but does not state ordering, pagination, whether message content/media is included, or any side effects such as marking messages read.

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

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

The description is a single front-loaded sentence with no filler. Every word contributes to the core purpose and parameter clarification.

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 list operation, the description is minimally viable. However, with no output schema and no annotations, it leaves out the exact return shape, ordering, and usage boundaries, making it adequate but not complete.

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

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

The description adds useful meaning for the required parameter by noting that jid can be a jid or phone number. The limit parameter is not described in words, though the schema's default, minimum, and maximum provide some semantics. Given 0% schema description coverage, the description only partially compensates.

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

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

The description clearly names the resource ('messages'), the scope ('from one chat'), and the recency ('recent'), and it clarifies the key parameter by allowing 'jid or phone number'. It does not explicitly name sibling tools, but the 'one chat' scope helps differentiate it from list_chats and search_messages.

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

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

There is no guidance about when to use this tool versus alternatives such as list_chats, search_messages, or ai_inbox. No exclusions, prerequisites, or explicit selection criteria are provided.

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

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

With no annotations, the description carries the behavioral burden. It communicates that names are 'live' when possible and that it 'falls back to cache when offline,' which is meaningful runtime behavior. It does not detail empty-cache behavior or staleness, but for a read-only listing tool this is adequate.

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?

Two short sentences with no filler. The core purpose is front-loaded, and the cache fallback is a separate second sentence that earns its place.

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

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

For a simple optional-parameter tool with no annotations or output schema, the description covers the main behaviors an agent needs: what is listed and how the tool behaves offline. It could add a note on output shape or fresh-vs-cache indication, but nothing critical is missing.

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 only parameter, limit, is not mentioned in the description, and schema description coverage is 0%; the description does not compensate for this gap. The schema itself does provide min/max/default, so this is not harmful, but the description adds no semantic value for the parameter.

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 an explicit verb ('List') and a distinct resource ('followed WhatsApp channels (newsletters)'), then adds the differentiator 'with live names.' This makes it easy to tell apart from siblings like list_chats, list_groups, and newsletter_metadata.

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

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

The description implies when to use it (needing followed newsletters, including when offline thanks to cache fallback), but it never explicitly says when to prefer this over sibling tools such as newsletter_metadata or list_chats, nor does it state any exclusions.

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

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

With no annotations, the description carries the behavioral burden, and it does disclose that this is a cache/session-scoped read operation. It does not cover what the returned items contain, whether the read affects the cache, or any freshness/ordering behavior, but for a simple list operation the disclosed caching semantics are meaningful.

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 compact sentence that front-loads the action, resource, and scope without repetition or filler.

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 cached-list tool, the description covers the key facts: what is listed, whose statuses, and the session/cache boundary. It leaves minor gaps such as return format and ordering, but no output schema exists and the tool is simple.

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

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

Schema description coverage is 0%, and the description says nothing about the 'limit' parameter or how it affects listing. The schema metadata (type, default, max, min) is present, but the description was supposed to compensate for low coverage and does not.

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 uses a specific verb ('List'), names the exact resource ('cached Status/stories (status@broadcast)') and defines scope ('mine + contacts seen this session'). This clearly differentiates it from sibling tools like fetch_status_text, post_status, and delete_status.

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

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

The phrase 'cached' and 'seen this session' gives the agent clear context for when this tool applies, while the sibling list implies live or individual-status alternatives. It does not explicitly name those alternatives or state when not to use this tool, so it misses the top tier.

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

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

With no annotations, the description carries full responsibility for behavioral disclosure. It does note that confirm must be true, which is a useful behavioral signal, but it does not explain side effects, whether following is reversible without newsletter_unfollow, expected errors, or what happens if confirm is false. This is thin for a tool that creates a subscription relationship.

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

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

The description is two short sentences with no filler. The action is front-loaded and the critical parameter requirement is stated immediately after. Every word earns its place.

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

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

Given no annotations, no output schema, 0% schema description coverage, and only two parameters, the description is not rich enough for an agent to invoke the tool with full confidence. It omits the meaning of jid, behavioral outcomes, and failure/error considerations, which are important for a state-changing follow operation.

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

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

Schema description coverage is 0%, so the description must compensate for both parameters. It adds meaning for 'confirm' by explicitly requiring true, but it leaves 'jid' completely unexplained—its format, semantics, or relationship to a channel are not addressed. The description only partially compensates for the lack of schema-level parameter documentation.

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

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

The description clearly states the action and resource: 'Follow a channel.' This is specific and distinct from sibling tools like newsletter_unfollow or newsletter_mute, though it does not explicitly name the alternative. The action verb is concrete and not a restatement of 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.

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

The only usage guidance is the parameter requirement 'Requires confirm=true,' which is a precondition for calling the tool, not guidance on when to choose this tool over alternatives. The description does not mention when to use newsletter_follow versus related tools or any exclusions, leaving routing to inference.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It lists the fields inspected but does not state that the operation is read-only, what the response format looks like, whether it can fail, or any permission/authentication requirements.

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

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

The description is a single efficient sentence with no filler, and the key scoping phrase 'one channel' is front-loaded. It is concise, though arguably too terse to cover behavioral context.

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 one-parameter metadata lookup, the core call is understandable. However, with no output schema, no annotations, and no explicit usage guidance, the definition leaves the agent to infer return behavior and when to use this tool versus its siblings.

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

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

Schema description coverage is 100%, and the single required parameter jid is already documented in the schema with an example. The description adds no additional parameter-level meaning, so baseline 3 is appropriate.

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

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

The description identifies a specific action ('Check') and a focused resource ('one channel') with the exact fields returned (name, description, subscribers, verification). It doesn't explicitly name the sibling alternatives, but the 'one channel' phrasing distinguishes it from list-style tools like list_newsletters.

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 context is implied by 'one channel' rather than explicitly stated. An agent can infer this is for fetching metadata about a single newsletter as opposed to listing all newsletters, but there is no explicit guidance on when to choose this over group_metadata or newsletter_follow.

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 disclosure burden. It discloses the confirmation gate ('Requires confirm=true') and implies a mutating toggle, which is useful, but it does not describe side effects, idempotency, or reversibility. This is adequate but not rich.

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 one short sentence with the action front-loaded and the critical prerequisite appended. Every word contributes; there is no filler or repetition of schema details.

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

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

For a simple 3-parameter toggle, the description plus schema gives an agent enough to call it: jid, muted, and confirm=true. But with no annotations or output schema, a bit more context about the effect of muting and the confirmation failure mode would make it fully self-sufficient.

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 only 33%, and the description helps by mapping 'mute/unmute' to the muted boolean and by flagging confirm as required. It adds no meaning for jid, which is the only required parameter and is left as a bare string in the schema.

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

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

The description states a specific action ('Mute/unmute') on a clear resource ('a channel'), which is more than a tautology and aligns with the tool name newsletter_mute. It doesn't explicitly contrast with sibling tools like newsletter_follow or newsletter_unfollow, but the action itself is unambiguous.

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

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

The description names the operation and the prerequisite 'Requires confirm=true', so it tells the agent how to invoke it correctly. However, it doesn't specify when to choose this over sibling tools such as newsletter_unfollow or list_newsletters, leaving selection largely to inference from the tool name.

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 behavioral burden. It usefully discloses that confirm=true is required, signaling a deliberate action, but it doesn't describe consequences, reversibility, or what happens when confirm is false or absent.

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

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

Two short sentences with no filler. The key safety constraint ('Requires confirm=true') is front-loaded and clearly separated from the main action.

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

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

The tool is simple, but the description omits what jid represents and any effect of the operation. It is adequate as a minimal callable definition, yet leaves several practical details—such as where jid comes from and outcome of the unfollow—unstated.

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 adds meaning only for confirm ('requires confirm=true'), while leaving the required jid parameter entirely unexplained in terms of what it identifies and how it should be sourced.

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 'Unfollow a channel' uses a specific verb and resource, clearly distinguishing it from sibling tools like newsletter_follow and newsletter_mute. It directly states the action and target.

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

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

The description includes an operational prerequisite ('Requires confirm=true'), but does not explicitly state when to use this tool versus alternatives such as newsletter_mute. Usage context is mostly implied by the tool name and the unfollow action.

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 behavioral burden. It does disclose the response behavior—pong, server time, and connection status—but it does not state whether any state changes occur, whether a live network check is performed, or how connection status is determined. Adequate but thin.

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 sentence with a colon-separated list of return values; no filler and the main action is front-loaded. Every part earns its place.

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

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

For a low-complexity tool with one optional parameter and no output schema, the description provides the essential return components. The remaining gaps—no routing hint against `connection_status` and no note on how `echo` affects the response—are minor.

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

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

Schema description coverage is 100%: the single optional `echo` parameter is fully documented in the schema. The description adds no parameter-specific behavior, but the baseline of 3 applies because the schema already does the heavy lifting.

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

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

The description names the action ('Ping MCP server') and lists observable outcomes (pong, server time, WA connection status), so an agent knows what the tool does. It does not explicitly differentiate it from the sibling tool `connection_status`, which also reports WA connection status, so it misses the full sibling-distinction mark.

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 about when to use `ping` instead of `connection_status`, `doctor`, or `auth_qr`. Since `connection_status` overlaps with the 'status koneksi WA' behavior, the lack of a routing clue is a notable gap.

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 disclosure burden. It adds a meaningful behavioral gate with 'Requires confirm=true' and clarifies that filePath switches the post to media. However, it does not disclose downstream effects such as visibility, irreversibility, or failure behavior.

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

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

The description is a single compact sentence with the core action front-loaded and the mandatory confirm requirement at the end. There is no filler or redundant restating of schema details.

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

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

With no output schema and no annotations, the description is not fully self-sufficient: it omits return behavior and side effects. Still, it states the required confirmation gate and the text/media branching, making it minimally viable for a simple create-status operation.

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

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

Schema coverage is 80%, so the baseline is 3. The description adds value beyond the schema by explaining that filePath turns the post into an image/video and by emphasizing that confirm must be true, which is not clear from the schema's bare boolean default.

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 concrete action ('Buat Status/story') and distinguishes text posts from image/video posts based on filePath. It is clear enough to separate this tool from the read/delete/status siblings, though it does not explicitly contrast with them.

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

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

The main usage directive is 'Requires confirm=true', which tells the agent that the operation needs the confirmation flag. There is no explicit 'use this instead of X' or when-not-to-use guidance, so usage is mostly implied from the verb 'Buat' and the resource name.

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 it does disclose the key behavioral trait: cached resolution first, live lookup only when needed. However, it leaves unclear what happens on cache miss or invalid LID, and it does not describe output shape or failure behavior.

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

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

A single, dense sentence renders the core transformation and the cache/live behavior with no filler. It is front-loaded and every phrase contributes.

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 resolver with no output schema, the description gives the essential return concept ('nowa + nama kontak') and the resolution strategy. Minor gaps remain around failure modes and response format, but most of what an agent needs to invoke it correctly is present.

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

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

The schema already has 100% description coverage for the single 'lids' parameter with min/max constraints and an example, which is the baseline. The description does not add parameter-specific meaning beyond telling the agent these are random LIDs, so no upgrade beyond baseline is warranted.

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 names a specific verb ('Ubah'/'resolve'), the resource ('LID acak'), and the result ('nowa + nama kontak'), which clearly differentiates it from sibling tools that send messages or list chats. The parenthetical even adds the resolution strategy, so an agent can tell what this tool alone does.

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

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

The purpose implies when to use it (whenever a random LID must be turned into a phone number/contact name) and the caching note gives operational context, but it never spells out when to use this versus any alternative or when not to use it. No sibling tool is named as a fallback.

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 the matching behavior via 'fragment', implying partial/substring matching, but it does not state whether the operation is read-only, what output shape to expect, or any limits. For a simple search tool, this is adequate but not rich.

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 short sentence, no filler, and the key scoping information ('name or phone fragment') is front-loaded. Every word earns its place.

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

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

For a single-parameter search tool with no output schema or annotations, the description is largely complete: it names the tool's purpose and the query semantics. It could add a note about output or explicitly distinguish from search_messages, but nothing critical is missing for invoking it correctly.

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

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

Schema has 0% description coverage, so the description must compensate. It does by clarifying that 'query' accepts a name or phone fragment, giving the agent concrete guidance on what to pass. This is valuable for a single parameter tool, though it doesn't mention possible exact-match formats or additional accepted values.

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

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

Description states a specific verb ('Find') and resource ('contacts') plus a clear scope ('by name or phone fragment'). This distinguishes it from sibling tools like search_messages and list_chats immediately, without needing to inspect schemas.

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

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

The description implies usage: when you need to find a contact by name or phone fragment. However, it does not explicitly route away from alternatives such as search_messages, nor does it state when not to use this tool. The guidance is inferred from the resource name and phrasing rather than stated.

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

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

No annotations are present, so the description bears full responsibility. It reveals that messages are cached, implying a non-live data source, but does not mention read-only nature, case sensitivity, result shape, or staleness implications.

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 five-word sentence that efficiently packs the operation, qualifier, and resource. No filler or redundancy; every word contributes semantic value.

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 no output schema and no annotations, the description omits return format, cache-specific caveats, and any comparison to list_messages. An agent can guess the basic call, but cannot fully judge expectations around result scope or freshness.

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

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

Schema description coverage is 0% and the schema only provides types and constraints. The phrase 'substring search' clarifies that the query parameter is the substring, adding meaning beyond the schema. However, the limit parameter's role is left to inference from its name and schema defaults.

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?

Description uses a specific verb 'search' with resource 'cached messages' and the qualifier 'substring', making the operation unambiguous. It also distinguishes itself from siblings like list_messages by emphasizing substring matching.

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

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

No guidance on when to use this tool versus alternatives such as list_messages. The description states what it does but not the context in which it should be preferred, missing exclusions or routing hints.

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 add one meaningful behavioral detail: 'Requires confirm=true.' It does not disclose side effects, failure behavior, or whether the action is reversible, but the confirmation requirement provides useful operational context.

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

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

The description is two short sentences with no filler. The core action is front-loaded, and the critical confirmation requirement is stated immediately. Every word earns its place.

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

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

For a tool with no annotations, no output schema, and zero parameter documentation in the schema, the description is too thin. It omits how to identify the recipient ('to'), what caption constraints are, and what happens when confirm is false. A simple tool still needs more operational detail.

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 adds meaning for filePath ('local file') and confirm ('requires confirm=true'), but leaves 'to' and 'caption' entirely unexplained. The agent still lacks enough information to fill these parameters correctly.

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

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

The description clearly states a specific verb ('send'), a resource ('local file'), and the supported content categories ('image/video/audio/document'). It is distinguishable from send_message by focusing on file transmission, though it does not explicitly name a sibling 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?

The description gives clear context: use this tool to send a local file rather than a text message. However, it does not explicitly state when to choose this over send_message or post_status, nor does it mention any exclusions or prerequisites beyond the confirmation flag.

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 supplied, the description carries the full burden, and it supplies real behavioral content: confirm must be true and rapid successive sends risk bans. It does not describe the outcome of a successful send or failure modes, but the safety-relevant behavior is disclosed.

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?

Two short sentences, with the action verb first and each sentence carrying a distinct fact. Nothing 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?

For a simple 3-parameter tool the description is mostly adequate, and the critical operational warnings are present. However, there is no output schema and no description of return values, failure behavior, or what confirm actually gates, so an agent still has some unstated assumptions about the call's result.

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

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

The schema already documents "to" as a JID/group/phone, and coverage is only 33%, so the description needed to fill in text and confirm. It adds meaning to confirm by stating it must be true, and "text message" loosely identifies the text parameter's role, but it adds nothing concrete about text content beyond the schema constraints.

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

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

The lead phrase "Send a text message" names a specific verb and resource and, by specifying "text," separates this tool from the sibling send_file and status-posting tools. It could be stronger by naming sibling tools explicitly, but the core intent is unambiguous.

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

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

The sentence "Requires confirm=true" gives a prerequisite that is not inferable from the schema, since confirm defaults to false. The 2s-gap warning provides an explicit operational cadence. It does not mention alternatives such as send_file or ai_reply, so it stops short of a full when-to-use statement.

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