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

Annotations already declare destructiveHint=false, idempotentHint=true and readOnlyHint=false, so the safety profile is covered structurally. The description adds no behavioral context beyond restating the operations: it says nothing about idempotency, reversibility, permissions, or what happens to an unblocked/blocked contact.

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 sentence with no filler; the listing behavior is stated first. It is efficient, though the compactness contributes to the missing detail noted elsewhere.

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 described. However, for a multi-action tool with an under-documented schema, the description should explain the action values and the account parameter; it only hints at the operations, leaving the agent to infer parameter semantics.

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%: the 'contact' parameter is documented as required for block/unblock, but 'action' and 'account' have no explanation. The description partially compensates by enumerating the three behaviors that correspond to the action enum, but it never names the enum values or explains 'account'.

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 resource (contacts bloqués) and the three concrete operations (list, block, unblock), giving a clear verb+resource scope. It does not, however, explicitly distinguish itself from related siblings like get_contact or search_contacts, 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?

There is no guidance on when to use this tool versus alternatives, nor any prerequisites or exclusions. The only usable signal is the implicit list of operations, which the agent must map onto the 'action' enum on its own.

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?

Annotations already declare readOnlyHint and openWorldHint, so the safety profile is covered. The description does add non-obvious context — the checked numbers are not notified — but says nothing about rate limiting, error behavior for invalid numbers, or what happens when the account parameter is omitted.

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 tight sentence with the core action and the key constraint front-loaded. Nothing is wasted, though it is arguably too brief for a tool with an undocumented parameter.

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 presence of an output schema means return values need not be described. However, for a two-parameter tool with an unexplained account parameter and no usage routing, the description leaves meaningful gaps an agent would have to guess at.

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 50%: the phones parameter is fully documented in the schema (format, max 50), but the account parameter has no description anywhere, and the description offers no hint about its role. With a mutation-relevant scope selector left entirely unexplained, the description fails to compensate for the 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: checks whether phone numbers have a WhatsApp account. The added 'sans rien leur envoyer' sharpens the scope (a lookup, not a message) and implicitly separates it from the send_* siblings. It does not name any sibling explicitly, so it falls 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?

No statement of when to reach for this tool versus alternatives such as search_contacts or send_message. The implied use case (validate numbers before messaging them) must be inferred from 'sans rien leur envoyer', with no prerequisites or exclusions spelled out.

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?

Annotations already declare readOnlyHint=false, destructiveHint=false, idempotentHint=false and openWorldHint=true, so safety profile is covered. The description adds the useful fact that members can be provided at creation time and that the new group can be attached to a community immediately, but it does not warn that repeated invocation creates duplicates (non-idempotent) or describe permission 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?

A single compact sentence with the action verb front-loaded and no filler. The second clause is slightly appended rather than structured, but 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?

An output schema exists, so return values need not be explained, and annotations cover the safety profile. The description covers both creation modes and the attachment capability; only auth/permission context and duplicate-creation behavior are missing, which is acceptable given the structured data provided.

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

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

Schema coverage is 60%, so the schema already documents community, participants and parent_community. The description mainly restates that duality, adding little syntax or format detail; the undocumented parameters (name, account) and the JID/number/name format for participants are left to the schema or unstated entirely. 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?

States a specific verb ("Crée") and resource ("un groupe"/"une communauté"), and even notes the composition (with members) and the parent-community attachment option. It is clearly distinguishable from siblings like update_group, join_group or link_to_community, though it never names them 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?

Usage is implied by the create semantics and by the two modes (group vs community), but there is no explicit guidance on when to prefer this over update_group, join_group, or link_to_community, and no stated prerequisites (permissions, session state).

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?

Annotations already flag destructiveHint=true, idempotentHint=true and readOnlyHint=false, so safety is covered. The description adds genuinely new behavior beyond them: the ~2.5-day window on own messages, the admin-only rule for others' messages, and 'Irréversible' reinforcing non-recoverability.

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 plus a one-word 'Irréversible.' — front-loaded with the scope, then the constraints, then the irreversibility warning. Every clause earns its place with no padding.

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 no explanation, and the preconditions for the destructive action are well covered. The gap is parameter documentation: with 0% schema coverage and no parameter mention, an agent must guess at chat/message_id semantics.

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 never mentions chat, account, or message_id. The parameter names are fairly self-explanatory, but the description does nothing to define formats, defaults, or what 'chat' accepts, leaving the schema to carry an undocumented burden.

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+resource ('Supprime un message') with an explicit scope ('pour tout le monde'), which cleanly separates it from edit_message and other siblings that modify rather than remove. It stops short of naming an alternative tool, but the destructive scope 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?

Gives concrete preconditions: own messages deletable for ~2.5 days, others' only when the caller is a group admin. That tells the agent when the call will succeed versus fail. It doesn't reference sibling tools, so it falls short of explicit 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?

Annotations already declare destructiveHint=true and idempotentHint=true, so the safety profile is covered. The description adds genuinely useful context beyond them: the 15-minute edit window and the fact that the replacement propagates to all recipients ('L'ancien texte est remplacé chez tous les destinataires'). It omits what happens on failure past the window (e.g., error vs. silent no-op).

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, zero padding, with the temporal constraint front-loaded alongside the core action. Every clause 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 mutation tool, the description supplies the two things an agent most needs beyond the rich annotations: the 15-minute window and the recipient-visible replacement. An output schema exists, so return values need not be explained. The unaddressed 'account' and 'chat' semantics are the remaining gap.

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 only 25% — just the 'text' field is documented ('Nouveau texte.'). The description does not explain 'chat', 'message_id', or the multi-account 'account' parameter, so it fails to compensate for the coverage gap in a 4-parameter tool.

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 ('Modifie le texte d'un de mes messages') and immediately scopes it with a hard constraint (within 15 minutes of sending). An agent can distinguish it from send_message (creates) and delete_message (removes) without opening another 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?

Gives a clear precondition — only the user's own messages, only within 15 minutes of sending — which tells the agent when this tool is even applicable. It does not, however, route to an alternative for the out-of-window or own-message-only failure cases.

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?

Annotations already establish that this is a read-only, non-open-world operation, so the safety profile is covered. The description adds scope by indicating what kind of details are returned for group versus person chats, but it does not disclose authentication needs, rate limits, or other behavioral context beyond the annotations.

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

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

The description is a single, front-loaded sentence that immediately identifies the resource and its type-dependent result. Every clause contributes to distinguishing group and person chat details, with no redundant or filler content.

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 and read-only annotations relieve the description of explaining return values and safety, so the core retrieval purpose is adequately conveyed. However, it does not resolve ambiguity with sibling tools like get_contact or get_profile, leaving an important routing gap for an agent.

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

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

Schema description coverage is only 50%: the required 'chat' parameter is documented as JID, international number, or chat name, but the optional 'account' parameter has no description. The tool description itself mentions no parameters and therefore does not compensate for the undocumented 'account' 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 states a specific resource (a chat/discussion) and distinguishes the returned fields for groups versus people, which is more than a tautology. However, it does not explicitly differentiate itself from sibling tools such as get_contact or get_profile, so sibling routing remains inferential.

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 rather than list_chats, get_contact, get_profile, or update_chat. The description only implies that it retrieves chat details; it provides no prerequisites, exclusions, or alternative-selection advice.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description adds a summary of the returned fields, but since an output schema exists this is largely redundant and it discloses nothing new about auth, scoping, 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 terse sentence fragment with zero filler, front-loaded on the resource. It is efficient, though it spends its one clause on return values rather than on disambiguation or usage.

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 an output schema present the return fields need not be explained, and annotations cover the read-only nature, so the description is not badly incomplete. Its real shortfall is the absence of any guidance on how this fetch differs from the many other lookup 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 50%: the required 'contact' parameter is documented with accepted formats (JID, international number, name), but 'account' has no description in either the schema or the description. The description does not compensate for that gap, giving a baseline minimum-viable score.

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

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

States a specific resource (a contact's card) and enumerates what it returns: names, number, last discussion, and shared groups. The read verb is implied by the name. However, it does nothing to distinguish itself from siblings like search_contacts or get_profile, so an agent must infer which to pick.

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 guidance, no prerequisites, and no mention of alternatives such as search_contacts for discovery or get_profile for profile data. The agent is left to guess the selection criteria on its own.

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?

Annotations already declare readOnlyHint=true and openWorldHint=true, so safety is covered. The description adds real behavioral context beyond that: it returns a local path AND attaches the file itself for images or reasonable-size audio, and explicitly declines to transcribe or describe. Auth requirements and rate limits remain unstated, keeping it short of a 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?

Two tight sentences, front-loaded with the action and its scope, followed by the return behavior. No filler or repetition.

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, the description does the right thing by explaining the return shape (local path plus attached file). However, for a tool with three undocumented parameters at 0% schema coverage, the definition leaves the agent without enough information on inputs to call it correctly.

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

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

Schema description coverage is 0% and the description supplies no parameter meaning at all: chat, message_id and account are never explained, nor are their expected formats. The phrase 'd'un message' only loosely hints at message_id. For a 3-param tool with zero schema documentation, this is a clear 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 (télécharge) and resource (le média d'un message) and enumerates the media types covered (vocal, image, vidéo, document, sticker). It is trivially distinguishable from the inverse sibling send_media, so an agent can select it 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?

The description implies its use case (fetch media from an existing message) but names no alternative and states no explicit when/when-not conditions. The clause 'Aucune transcription ni description : c'est au modèle de les faire' is useful negative scoping that tells the agent this tool will not do the downstream work, but it is not a routing guideline.

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?

Annotations already declare readOnlyHint=true and openWorldHint=false, covering the safety profile. The description adds nothing behavioral — no mention of the default context window (5), the allowed range, or what happens at discussion boundaries.

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 with no filler, and the core concept (message + surroundings) is front-loaded. It is efficient, though notably under-specified rather than 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 return values need not be explained. However, for a four-parameter read tool with 25% schema coverage, the description leaves account/chat semantics and sibling differentiation unexplained.

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 25%: just "around" is documented. The description doesn't clarify chat, account, or message_id semantics, so for three of four parameters an agent gets no meaning beyond the raw names.

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 conveys a specific resource — a message plus its surrounding messages in a discussion — which is distinct from list_messages or get_chat. It lacks an explicit verb and doesn't name a sibling it should not be confused with, but the scope is decipherable.

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?

"par exemple après une recherche" gives one implied context (following a search), which suggests usage but names no alternative tool or exclusion. There is no guidance on when not to use it versus list_messages or search_messages.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description usefully adds the shape of the data returned (device count, business profile presence), but says nothing about auth requirements, rate limits, or behavior for unknown contacts. Adequate but not rich given the annotation coverage.

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

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

A single front-loaded sentence that names the resource first and then lists fields with no filler. Efficient and well-structured, only slightly compressed by the field enumeration.

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 an output schema present, the description need not explain return values, and the readOnly annotation covers safety. The listed fields give an agent enough to know what comes back, leaving only the sibling-routing guidance as a genuine gap.

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 50%: the required 'contact' param is documented as 'JID, numéro ou nom', but the optional 'account' param is undocumented in both schema and description, and the description adds no parameter meaning at all. The mid-range coverage sets the baseline at 3, but the description does nothing to compensate for the 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 (retrieve) and resource (a contact's public profile) and enumerates the distinct fields returned: Info text, photo, verified name, device count, and business profile. This differentiates it functionally from siblings like get_contact, though it never explicitly names that boundary.

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_contact, search_contacts, or any other sibling, and no mention of prerequisites or exclusions. The agent must infer the use case purely from the listed fields.

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?

Annotations already declare readOnlyHint=false, idempotentHint=true and destructiveHint=false, and the description adds the genuinely useful detail that `reset` invalidates the previous link. That detail sits in mild tension with destructiveHint=false and idempotentHint=true (a reset replaces the link rather than reproducing the same result), but it reads as a nuance rather than a direct contradiction. No permission error behavior or rate-limit context is given.

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

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

A single compact sentence that front-loads the resource and the admin prerequisite, with no filler. It is arguably too terse for a 3-parameter tool, but nothing in it 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?

An output schema exists, so return values need not be described, and the admin prerequisite plus reset semantics are covered. Still, the two undocumented parameters (`chat`, `account`) and the absence of any routing versus preview_group_link leave the definition only minimally sufficient for an agent to invoke 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 coverage is only 33%: `chat` and `account` are completely undocumented in both schema and description. The one parameter the description touches, `reset`, is already fully described in the schema ('Invalider l'ancien lien et en créer un nouveau'), so the description adds no meaning there. It fails to compensate for the coverage gap on the other two 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 names the resource (a group's invite link) but uses a bare noun phrase with no verb, so the agent must infer whether it retrieves, creates, or regenerates the link. It also never distinguishes itself from the sibling preview_group_link, which plausibly serves a similar purpose. The parenthetical about needing administrator rights adds useful framing but not a clear action statement.

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 one concrete usage condition ('il faut en être administrateur') and explains what `reset` does, which is more than nothing. However, it never says when to prefer this tool over preview_group_link, nor what happens if the caller is not an admin. Usage is implied rather than spelled out.

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?

Annotations already declare idempotent=true, destructive=false and openWorld=true, so the safety profile is covered. The description adds only that the operation is a binary accept/refuse decision, but does not disclose batch semantics, permission requirements, or what happens to requests already 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?

A single front-loaded sentence with no filler, so nothing wastes space. It is arguably too terse for the tool's complexity, but the structure itself is 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?

An output schema exists, so return values need not be explained, and annotations cover the safety profile. However, with only 25% schema coverage and 4 parameters, the description leaves usage flow and required inputs ('chat' + 'approve') unaddressed, so it is only marginally 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 only 25% – just 'participants'. The description mentions no parameters at all, leaving 'chat', 'account' and the 'approve' boolean entirely undocumented outside their types. The accept/refuse wording hints at 'approve' but never names or maps it.

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 pair (accept/refuse) and resource (group join requests), so the agent knows exactly what action is performed. It does not, however, distinguish this from siblings like list_join_requests or request_history within the description text itself.

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

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

There is no when-to-use guidance, no mention of the paired read tool list_join_requests, and no stated preconditions (e.g. that requests must first be listed). The agent must infer the workflow entirely.

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?

Annotations already declare readOnlyHint=false, openWorldHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds nothing beyond purpose: it does not mention auth/account requirements, whether the join may require admin approval, or what happens on failure, so it contributes no behavioral context the annotations lack.

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 sentence with no filler. It is efficient, though its brevity comes at the cost of the missing usage and behavioral detail scored above.

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 annotations carry the safety profile. However, for a write/mutation tool the description omits account selection, approval-request behavior, and when to prefer preview_group_link, leaving clear gaps.

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

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

Schema coverage is 50%: the required link parameter is well documented in the schema as a URL or bare code, but the account parameter has no description. The description's mention of the invitation link reinforces the link parameter but adds no syntax or format detail beyond the schema, so it does not compensate for the undocumented account 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?

States a specific verb (rejoint/joins), resource (un groupe), and mechanism (par son lien d'invitation), so the action is unambiguous. It does not name or distinguish itself from the obvious siblings preview_group_link or group_invite_link, which would make the boundary sharper.

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 alternatives such as preview_group_link (which presumably shows the group before joining) or handle_join_requests. The agent gets no exclusions, prerequisites, or context for choosing this tool.

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

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

Annotations already declare destructiveHint=true and idempotentHint=true, so safety is covered. The description adds real behavioral context beyond that: leaving is effectively irreversible because re-entry requires a fresh invitation.

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 operation and followed by the single most important consequence. Nothing is padded and every clause 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 destructive mutation with an output schema, the description plus annotations convey the essential risk and irreversibility. It is only slightly short on parameter/auth context, which the annotations partly offset.

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 names no parameters. Neither the required 'chat' target nor the optional 'account' selector is explained, so the description fails to compensate for the documentation 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?

The description states a specific verb and resource ('Quitte un groupe' / leaves a group), making the operation unambiguous against write siblings like join_group. It does not explicitly name an alternative tool, so it stops at clear-but-undifferentiated.

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 explicit when-to-use guidance or comparison to alternatives such as join_group or update_group_participants. The second sentence is a consequence warning rather than usage routing, leaving the agent to infer the scenario.

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?

Annotations already declare readOnlyHint=false, openWorldHint=true, idempotentHint=true and destructiveHint=false, so the safety profile is covered. The description's real added value is disclosing the dual-mode behavior (attach vs. detach), which the annotations do not express. It says nothing about required permissions or the effect of detaching on existing members.

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, front-loaded with the primary operation and the inverse flagged via `unlink`. No wasted text, though the parenthetical inline backtick reference is slightly terse.

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?

A four-parameter mutation tool with only 25% schema coverage and no annotation explanation of the `account` parameter. The output schema exists so return values need not be described, but the description leaves the target-account semantics and prerequisite conditions entirely undocumented.

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 only 25% and the description effectively covers one parameter (`unlink`), whose meaning the schema already states in its own description. The `community`, `group` and especially the un-nullable `account` parameters get no added meaning from the description, so it fails to compensate for the sparse 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 names a specific verb pair and resource: attach an existing group to a community, or detach it. An agent can tell what the tool does. It does not differentiate itself from siblings like update_group or update_group_participants, which mention nothing about communities.

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 when-to-use guidance is given. It clarifies that `unlink` selects the inverse operation, but never states when to call this instead of update_group or the other group-management siblings, nor any prerequisites (e.g. that the group must already exist and be owned/administered).

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?

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description adds the useful detail that results include connection state and data volume, but says nothing about scope (all accounts vs. only served/active ones), result size, or ordering that the output schema may not convey.

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 sentence with no filler. The verb and resource lead, and the payoff (state + volume) follows immediately; nothing could be removed without losing information.

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

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

For a zero-parameter read tool with an output schema present, the description need not explain return shapes, and it correctly does not. It is nearly complete; the only shortfall is the missing distinction from session_status/check_whatsapp, which matters for selection in this sibling set.

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 zero parameters, which is the baseline-4 case per the rubric. The description appropriately focuses on what the listing returns rather than inventing parameter semantics, and the empty schema is consistent with the described behavior.

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 ('Liste les comptes WhatsApp') and even names what the listing surfaces — connection state and data volume. It is clear without opening the schema, though it does not differentiate itself from the semantically adjacent sibling 'session_status', which also concerns connection state.

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, when-not-to-use, or alternative routing guidance. An agent cannot tell from this text whether to call list_accounts or the related session_status/check_whatsapp tools for connection information, so it must infer selection entirely on its own.

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?

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description adds useful context beyond the schema: the ordering (pinned first, then most recent) and that each entry carries the last message. It does not describe pagination behavior despite offset/limit parameters.

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 sentence with the verb first and no filler. It is efficient, though packing ordering and return-content into the same clause makes it slightly dense.

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?

A read-only list tool with an output schema, so return structure needn't be explained, and annotations cover the safety profile. The description supplies ordering and content context; only pagination semantics are left implicit, which is a minor gap.

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 67%, so the schema already documents kind, limit, query, and include_archived; account and offset are undocumented there. The description implies the chat kinds covered by "individuelles et groupes" but adds no filtering or format detail beyond what the schema provides. 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?

Names a specific verb (list) and resource (discussions/chats), and adds scope detail: both individual and group chats, ordered pinned-then-recent, including the last message. It does not explicitly differentiate itself from close siblings such as list_recent or list_messages, so it falls 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?

The description states what is listed but gives no when-to-use guidance, no exclusions, and names no alternative. With siblings like list_recent and search_messages available, an agent gets no help deciding between them.

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?

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered; the description adds the administrator permission requirement, which annotations do not convey. It still says nothing about pagination or result volume for a growing request queue.

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 sentence with the resource first and the access constraint second; nothing is wasted. It is short to the point of being under-specified, but structurally sound.

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 the read-only/profile context is covered by annotations. The gap is that neither description nor schema defines what identifier 'chat' should contain, which is the one thing an agent must get right to call this tool.

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

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

Schema coverage is 0%, so the description must compensate and it largely does not. 'D'un groupe' loosely maps to the required 'chat' parameter but gives no expected format (JID, phone number, group name), and the optional 'account' parameter is entirely unexplained.

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 resource and scope: pending join requests for a group awaiting approval. The qualifier 'en attente d'approbation' implicitly separates it from the sibling handle_join_requests (which acts on those requests), though the sibling is never named.

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 states a prerequisite ('il faut en être administrateur'), which is real usage guidance, but gives no explicit when-to-use/when-not-to-use framing and never points to handle_join_requests as the follow-up action. Usage is implied rather than directed.

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?

Annotations already cover the safety profile (readOnlyHint=true, openWorldHint=false), so the description's added value is real: it discloses result ordering, the direction of pagination, and that reactions, quoted replies, edits and deletions are merged into each message. That last point is meaningful behavioral context an agent would not infer from 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?

Two tight sentences with no filler, and the ordering constraint plus pagination hint are front-loaded. Nothing redundant is present; it could arguably state one routing rule for a perfect score.

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 an output schema present, return values need not be re-explained, and the description covers the two things an agent must know before calling: ordering semantics and how to page backwards. Nothing essential for correct invocation 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?

Schema coverage is 88% with per-field descriptions, so the schema already explains chat, kind, limit, since/until, before and sender. The description only adds a conceptual link between the 'before' parameter and the 'next_before' cursor, which is helpful but marginal against the schema's own 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?

States a specific verb and resource ('Messages d'une discussion') plus the ordering contract (chronological, newest page first). It is distinguishable from siblings like search_messages or get_message_context, though it never names an alternative 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?

Provides genuine usage direction for pagination ('next_before donne la page plus ancienne'), which tells the agent how to walk backwards through history. However, it gives no guidance on when this tool should be chosen over search_messages, list_recent, or get_message_context.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so safety is covered. The description adds that results are chronological and span all discussions, which is real behavioral context, but says nothing about pagination, limits, or how include_mine affects results beyond what the schema states.

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 sentence that leads with the scope (all discussions, chronological) before the use-case framing. Efficient, though the final 'quoi de neuf' flourish and the unquoted French quotation marks are slightly ornamental.

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 an output schema present, return values need not be explained, and the description covers scope and ordering. It is adequately complete for an agent to call it, with the only gap being explicit sibling differentiation.

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 schema already documents limit, since, chat_kind and include_mine with units and defaults. The description only echoes the 'since' concept ('depuis un moment donné') and adds no format or interaction detail beyond the schema; baseline 3 is correct.

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+resource: everything that happened since a given moment, across all chats, in chronological order. The 'toutes discussions confondues' scope is a meaningful discriminator, but it never names the obvious sibling (list_messages) to make the boundary explicit.

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?

'le point de départ pour « quoi de neuf »' implies a broad 'what's new' recap use case, which is useful orientation. However there is no explicit when-to-use vs list_messages or search_messages, and no stated 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?

Annotations declare readOnlyHint=false and idempotentHint=true; the description adds real value beyond that by disclosing the externally visible side effect (read receipts / blue ticks are sent to the other party), which the annotations do not convey. It does not mention permission or account-switching requirements, but the annotation coverage makes the lower bar appropriate.

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 efficient sentence with the action front-loaded and the consequence in the trailing clause; nothing is wasted. It is arguably too terse for the parameter documentation it omits, but as structure it is clean.

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 no explanation, and the annotations carry the safety profile. The remaining gap is parameter identification at 0% coverage, which the description does not fill for either 'chat' or 'account'.

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 not. 'Discussion' loosely maps to the required 'chat' parameter, but no format (JID/phone/ID) is given, and the optional 'account' parameter is never mentioned.

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 ('Marque une discussion comme lue') and even names the observable effect ('envoie les accusés de lecture (coches bleues)'). An agent can tell this apart from read-oriented siblings like get_chat or list_messages, though no sibling is named 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?

Usage is implied rather than stated: the reader infers one calls this after receiving messages the user has seen. There is no explicit when-to-use, when-not-to-use, or comparison against alternatives such as list_messages or get_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?

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description does add one genuinely useful behavioral fact beyond them: the caller is not added to the group, which distinguishes a passive fetch from a membership mutation. It says nothing about auth/account requirements or rate limits on linked lookups.

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 short sentence that front-loads the resource and immediately qualifies it with the non-joining constraint. No filler, 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 values need not be explained, and annotations cover safety. However, for a tool whose 'account' parameter is undocumented and whose behavior on invalid/expired links or non-member access is unstated, the description leaves real gaps beyond what structured fields provide.

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 50%: the 'link' parameter is described in the schema as a WhatsApp invite URL or bare code, but 'account' has no description anywhere. The prose ('à partir de son lien d'invitation') merely echoes the schema wording for link and adds nothing, leaving the account parameter fully unexplained.

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 (preview/aperçu) and resource (a group reached via its invite link), and the clause 'sans le rejoindre' explicitly carves it out from join_group. It stops short of naming any sibling tool outright, so an agent must infer the contrast rather than read it.

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?

'Sans le rejoindre' implies the use case (inspecting a group before committing to join_group), but the description never states when to prefer this over join_group, group_invite_link, or list_join_requests. Usage is only inferable, not 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?

Annotations already declare destructiveHint=false, idempotentHint=true, openWorldHint=true and readOnlyHint=false, so safety is well covered. The description adds that the tool performs both reads and writes, which is mild extra context, but it discloses nothing about permissions, reversibility of changes, or what a modification affects.

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 sentence with no filler, stating resource, example settings, and the read/modify modes. The trailing ellipsis leaves the enumeration open-ended, which is slightly loose, but overall it is tight and economical.

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 no coverage, and annotations carry the safety profile. For a 3-param tool, the description covers the read/write duality and setting types competently, but the undocumented 'account' parameter and the absence of any usage context leave modest gaps.

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

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

Schema description coverage is 67% and the schema already lists the allowed value/setting tokens. The description usefully renders those settings in plain language (vu à, en ligne, photo, statut, confirmations de lecture...), reinforcing the 'setting' param, but it says nothing about 'account' and adds no syntax beyond the schema. Baseline 3 fits.

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 resource (privacy settings), the dual verb (read or modify 'en lecture ou pour en modifier'), and enumerates concrete setting types (last seen, online, photo, status, read receipts, group-add). An agent can tell what the tool governs. It does not, however, contrast itself against nearby siblings such as blocklist or set_about, leaving a small differentiation gap.

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 description says the tool can read or change a privacy setting but gives no explicit when-to-use, preconditions, or alternatives. The read-vs-write distinction (setting param absent = read-only) lives in the schema, not here. This is functional but leaves the agent to infer the calling context.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false and idempotentHint=true, so safety is covered. The description adds genuinely useful behavior the annotations do not: the empty-emoji removal path and the fact that a new reaction replaces the previous one (single reaction per user).

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 compact sentence covering the react path plus a short second clause for the removal/replace semantics. Nothing is wasted and the primary action 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?

An output schema exists so return values need no explanation, and annotations carry the safety profile for this mutation. It is nearly complete, but the three undocumented identifier parameters leave a small gap for a 4-parameter write tool.

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

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

Schema description coverage is only 25% — 'chat', 'message_id' and 'account' are undocumented in both schema and description, so there is a real gap. The description does explain the emoji parameter's empty-string semantics, which duplicates the schema entry, so it compensates only partially.

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 ('Réagit à un message') plus the removal variant, so the agent knows exactly what the tool does. It does not name or contrast with any sibling tool, which keeps it 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?

The description implicitly tells when to use it ('empty emoji' for removal), which is the key branching condition. However it names no alternatives and gives no prerequisites, e.g. whether the message must be in your own chat or what account selection implies.

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?

Annotations declare openWorldHint=true, idempotentHint=false, destructiveHint=false, so the safety frame is partly covered. The description adds genuinely non-inferable behavior: it is an asynchronous request, blocks up to 45 seconds, and requires the phone to be online. It doesn't say what happens on timeout or whether repeated calls are safe, but the added context is substantial.

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 tight sentences, front-loaded with the core action and followed by the online prerequisite, the 45 s wait, and the next-step hint. Every clause 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?

An output schema exists, so return values need not be explained. The definition covers the async wait, the online requirement, and the follow-up call, which is enough for an agent to use it correctly. The only gap is the undocumented `account` parameter in a multi-account setting.

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% (only `count` is documented, with range and default). The description implies the `chat` parameter via "d'une discussion" but says nothing about `account`, nor does it clarify `count` beyond what the schema already states. With low coverage and no real param compensation, this falls below the MID-example baseline of 3.

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

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

States a specific verb (demander) plus resource (messages plus anciens) and the exact scope: older than the oldest message known in a chat. It also distinguishes itself from the sibling list_messages by explaining the relationship (this backfills, list_messages then displays with `before`). It does not, however, differentiate itself from list_recent or search_messages, which also surface 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?

Clear context for when to invoke it (to obtain history older than what is already known) plus an explicit prerequisite (the phone must be online) and the follow-up action (`list_messages` with `before`). No explicit when-not-to-use or failure path (e.g. what if the phone stays offline past 45 s), so it stops short of full guidance.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description adds useful matching context (address book, WhatsApp name, company name, phone-number substring), but says nothing about result limits, ranking, or auth implications beyond the schema's limit note.

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 sentence stating verb, resource, and the two lookup modes with zero filler. Every clause 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?

An output schema exists, so return values need not be explained, and the read-only nature is annotated. The description covers the search semantics well; the only real gap is the unexplained 'account' parameter.

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 67%: query and limit are documented in the schema, while 'account' has no description anywhere. The description's mention of 'nom d'entreprise' and 'carnet' adds a little meaning to the query parameter but does not compensate for the undocumented account parameter, so baseline 3 is right.

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 gives a specific verb ('Cherche') plus resource ('contacts') and spells out the two matching modes (by name or by partial number), so the agent knows exactly what the tool returns. It does not explicitly differentiate itself from neighbors like get_contact or check_whatsapp, so it falls 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 rather than stated: the agent can infer it should use this for fuzzy/partial lookups instead of fetching a single known contact, but no alternative tool is named and there are no when-not conditions. Adequate but with clear gaps.

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?

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description adds genuinely useful search semantics beyond annotations: AND logic across all words, accent and case insensitivity, and result ordering (most recent first). It stops short of describing pagination or result shape.

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 tight sentences, zero waste, with the core purpose and the query-matching rules front-loaded. Every clause 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?

An output schema exists so return values need no explanation, and the query semantics are well covered. However, for an 8-parameter tool, the description is silent on the time-range (since/until), account, and pagination (offset) parameters, leaving the agent dependent on partial schema descriptions.

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 half the parameters (since, until, account, offset) are undocumented everywhere. The description reinforces the query semantics (all words required, accent/case-insensitive) and the searchable fields, but adds nothing for the undocumented time-range and account parameters, so it does not fully compensate for the 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+resource ('Recherche plein texte dans les messages') and clarifies scope by naming what fields are searched (text, captions, filenames) and ordering (most recent first). It is distinguishable from siblings like list_messages or get_message_context, though it does not name them 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?

The description conveys implied usage (find messages by text) but gives no when-to-use guidance against alternatives such as list_messages or get_message_context, and no exclusions or prerequisites. Nothing tells the agent under which conditions this is the right choice.

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?

Annotations already declare readOnlyHint=false, openWorldHint=true, idempotentHint=false, and destructiveHint=false, so the safety profile is covered. The description adds nothing behavioral beyond that — no mention of delivery, destination resolution, rate limits, or what a non-idempotent send implies on retry.

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 sentence with the verb first and no filler. It is efficient, though its brevity is also the source of the missing guidance rather than an intentional tight 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?

An output schema exists, so return values need not be described, and the tool itself is simple. However, with 6 parameters at 0% schema coverage, the omission of the required 'chat' destination and the 'account' scope leaves the agent under-informed for invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It names latitude/longitude and flags name/address as optional, but the required 'chat' target and the 'account' parameter are never explained, and no format or default semantics are given for any 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?

States a specific verb (Envoie) and resource (a position with latitude/longitude plus optional name/address), which cleanly separates it from the send_message / send_media / send_poll siblings without naming them. It does not explicitly reference any sibling, but the resource is distinctive enough to route an agent correctly.

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 infers you call this instead of send_message when you want to share coordinates. There is no statement of prerequisites (which chat/account context is needed), no when-not guidance, and no explicit 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?

Annotations already establish this is a non-read-only, open-world, non-idempotent write, so the safety profile is covered. The description adds the behavioral detail that media type is auto-deduced from the file extension and that as_voice_note changes delivery mode, but says nothing about permissions, failure modes, or side effects.

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 front-loads the core action and enumerates the media types without waste. Nothing extraneous and no buried 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?

An output schema exists so return values need no explanation, and the description covers the media-type mapping and voice-note flag. However, for a six-parameter mutation tool with low schema coverage, chat target, caption, reply_to and account are left entirely unaddressed, leaving 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?

Schema coverage is only 33% (chat, caption, reply_to, account are undocumented), so the description should compensate more than it does. It touches the type-from-extension logic and as_voice_note semantics, but both largely echo the path and as_voice_note schema descriptions, leaving the other four parameters unexplained.

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 gives a specific verb ('Envoie') and resource ('fichier local') and enumerates the media types handled (image, vidéo, audio, document, message vocal), clearly separating it from send_message, send_location and send_poll. It stops short of explicitly naming those siblings, so it is clear but relies on inference for differentiation.

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

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

The description implies the use case (sending a local file) but offers no explicit when-to-use guidance or routing against alternatives like send_message or get_media. The only conditional statement, as_voice_note for OGG Opus, is parameter-level, not tool-selection guidance.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=false and openWorldHint=true, so the safety profile is covered. The description adds the genuinely useful trait that sending is irreversible once it leaves ('Irréversible une fois parti'), plus the post-hoc remedy via delete_message. It still omits auth/account requirements, so not a 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?

Two short, front-loaded sentences with zero filler: the action first, then the irreversibility caveat with the sibling pointer. Every clause carries information.

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

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

Output schema exists, so return values need no explanation, and annotations cover mutation/open-world traits. The description covers what the tool does, its optional features and its irreversibility. The only real gap is the unexplained account parameter for multi-account use.

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

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

Schema description coverage is 60%, so the schema documents chat, mentions and reply_to but leaves text and account bare. The description adds meaning for reply_to (quoting) and mentions, matching those fields, but contributes nothing about the untyped account parameter or the text field, so it 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?

States a specific verb+resource ('Envoie un message texte') and implicitly separates itself from send_media, send_poll and send_location via the 'texte' qualifier. It does not name those siblings explicitly, so it falls just 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?

The description notes optional reply ('en réponse à un message (cité)') and mention behavior, and points to delete_message as the recourse for the irreversibility, which is useful context. However, it never states when to pick this over send_media/send_poll/send_location, so usage is only implied.

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

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

Annotations already declare non-read-only, non-idempotent, open-world behavior, so the safety profile is covered. The description adds useful constraints ('2 à 12 choix', single vs multiple per person) but says nothing about permissions, visibility, or what state the poll mutates.

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 tightly-packed sentence with zero filler, and the core constraints are front-loaded inside the parenthetical. Efficient, though it omits contextual information that would still earn 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?

An output schema exists, so return values need no explanation, and annotations carry the safety profile. Yet for a 5-parameter mutation tool, the description omits required-parameter context (chat, question) and any usage conditions.

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 40%: the description usefully documents the options count limit and the multiple-choice semantics, mapping to two of five parameters. However, 'chat', 'account', and 'question' remain unexplained in both schema and description.

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

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

States a specific verb+resource in French ('Crée un sondage'), making it immediately distinguishable from the many send_message/send_media siblings. It does not explicitly name a sibling or scope, but the poll resource is unique in the toolset.

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 when-to-use guidance, no prerequisites, and no mention that a target chat is required before creating the poll. The agent must infer all invocation context from the schema.

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?

Annotations already declare non-destructive, idempotent, open-world behavior. The description adds useful context that the effect is transient presence ('paused' stops it) and that it should precede a send, but it does not state whether the signal auto-expires, whether it needs an active session, or how it interacts with read receipts/typing indicators.

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 that front-loads the core action and appends the timing advice, with no filler. The parenthetical state labels are slightly redundant with the schema but aid readability.

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 annotations cover the safety profile. Still, for a 3-parameter mutation tool with 33% schema coverage, the description leaves gaps around the chat/account parameters and about the ephemeral nature of the presence signal.

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 does add meaning for `state` by naming composing/recording/paused in prose. It says nothing about the required `chat` identifier format or the optional `account` parameter, so the low-coverage parameters are only partially compensated.

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 action (displaying/stopping a presence state) on a specific resource (a chat), and enumerates the three states it controls. It clearly distinguishes this as a presence-signalling tool rather than a message-sending tool, though it does not name the send_message sibling it complements.

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?

"À utiliser juste avant un envoi" gives a concrete timing cue for when to call it, which is genuine usage guidance. However, it offers no when-not conditions, no mention of prerequisites, and does not tell the agent to use send_message for the actual content.

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?

Annotations already declare destructiveHint=true, idempotentHint=true, readOnlyHint=false and openWorldHint=true, so the safety profile is covered. The description still adds substantive behavior the annotations cannot express: the session is terminated server-side, the device vanishes from the phone, stored messages survive on disk, and reversal requires re-pairing.

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 with the action front-loaded, followed by the two consequences that matter (session closed on WhatsApp, local messages retained) and the reversibility caveat. No 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?

An output schema exists, so return values need not be described, and the annotations cover destructiveness/idempotency. The description supplies the durable side effects an agent needs to warn the user about; the only missing piece is the account parameter's expected format and any auth prerequisite.

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?

There is one required parameter ('account') with 0% schema description coverage, and the description does no work to compensate — it says an account is unlinked but never indicates what identifier form is expected (phone number, JID, account id) or how to obtain it. With a lookup tool like list_accounts as a sibling, this is a real 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 (unlinking an account, closing the WhatsApp-side session and removing the device) rather than restating the tool name 'session_logout'. The parenthetical clarifies the mechanism, which is more informative than the name alone, though it never names the sibling session_pair that performs the inverse action.

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 operative context: the change is irreversible and requires a new pairing, which implicitly tells the agent when this tool is appropriate versus session_pair. It stops short of an explicit 'use X instead' routing statement or any precondition (e.g. which account must be paired first).

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

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

Annotations already declare this is a non-readonly, non-idempotent, open-world write, so the safety profile is covered. The description adds real workflow context beyond that: the operation yields an 8-character code the user must type on the phone, and history syncs asynchronously minutes later. It does not explain what happens on re-invocation or failure.

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 tightly written sentence that front-loads the action, then the immediate result, then the delayed follow-up. No redundant or filler text.

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 an output schema present, return values need no elaboration, and annotations carry the mutation/safety profile. The description supplies the essential workflow (code entry, delayed history), leaving only edge cases like already-paired accounts or code expiry 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 100%, and the schema already documents both the phone number format and the account alias charset. The description adds no parameter-level meaning beyond that, so the baseline of 3 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 a specific verb and resource ('Lie un nouveau compte WhatsApp à ce serveur'), which no sibling shares, and adds the observable outcome (an 8-character code). It never explicitly contrasts itself with the related session_logout or session_status tools, so sibling differentiation is left implicit.

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 itself (add a new account), and the note that history arrives shortly gives useful context about what follows. However, there is no explicit when-to-use vs. when-not, no prerequisite (e.g., must you be logged out first?), and no alternative named.

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?

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description adds only a list of returned fields, which is largely redundant with the existing output schema, and says nothing about auth requirements, null handling for the default account, or side effects.

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 sentence fragment with no filler; the resource is stated first and the enumerated contents follow. It is appropriately sized for a simple read tool, though the fragment lacks an explicit verb.

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 an output schema, full parameter coverage, and clear annotations, the description supplies enough for an agent to call this correctly. The only real gap is the absence of any positioning against the many sibling session/account 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 100% and the single 'account' parameter is already documented as an optional alias. The description adds no additional meaning about format or selection behavior, so the baseline 3 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 a specific resource ('État d'un compte') and enumerates exactly what the status comprises (connexion, numéro, dernière connexion, volume de messages, période couverte). It is clear what the tool reports, though it does not explicitly differentiate itself from siblings like list_accounts or session_logout.

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 guidance, no prerequisites, and no mention of alternatives. The closest thing to a usage cue is the implied 'call this to inspect an account', but nothing states when an agent should prefer it over list_accounts or other session tools.

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

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

Annotations already declare destructiveHint=true, idempotentHint=true and openWorldHint=true, so the safety profile is covered structurally. The description adds nothing beyond the purpose statement — it does not warn that existing 'Infos' text is overwritten, nor mention auth/account requirements, so it contributes no behavioral context the annotations don't already carry.

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 short sentence with zero filler and the operation front-loaded. It is efficient, though its brevity is partly the cause of the missing usage and parameter detail noted elsewhere.

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 annotations cover the safety profile. However, for a destructive write tool the description never states that the previous 'Infos' text is replaced or which account is affected, leaving meaningful gaps for an agent choosing and invoking it.

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 only 50%: 'about' is documented in the schema, but the 'account' parameter has no description in either the schema or the tool description. For a multi-account context (list_accounts is a sibling), the description should clarify which account the change targets, and it 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 states a specific verb and resource in French — 'Change le texte « Infos » de mon profil' — which unambiguously identifies a profile 'About' field mutation. It is clear on its own, though it does not name or contrast itself with any sibling (e.g. get_profile, which reads rather than writes the same data).

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 alternatives such as get_profile or privacy_settings, nor any stated preconditions (e.g. needing a paired session). The single sentence only restates the operation, leaving the agent to infer when it applies.

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?

Annotations already declare readOnlyHint=false, idempotentHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description does add one genuine behavioral fact beyond them — the settings are synchronisés sur tous mes appareils — but it never states whether omitted fields are left unchanged, which is the central behavioral question for a 6-field partial-update 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?

A single front-loaded sentence listing the target resource first and the settable operations second, with no filler. It is appropriately sized; the only structural weakness is that a noun phrase rather than a verb leads, and the list is separated by colons/commas rather than tied to the parameter 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?

An output schema exists, so return values need not be explained, and annotations carry the safety profile, which lowers the burden. Still, for a 6-parameter mutation with 33% schema coverage, the description omits what chat refers to, what account controls, and whether this is a partial or full replacement update — an agent could call it correctly only by guessing.

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 only 33% (only mute and unread carry descriptions), so the description should compensate more than it does. It does name four of the six fields — archive, pin, mute, unread — which maps them to user-facing actions, but it says nothing about the required chat identifier or the account parameter, and adds no value semantics beyond the names.

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?

It names the resource (une discussion) and enumerates the operations available — archiver, épingler, mettre en sourdine, marquer comme lu/non lu — so an agent knows this is the chat-settings mutation, not a message or group operation. It does not, however, distinguish itself from the overlapping sibling mark_read, which also flips read/unread state.

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 guidance, no prerequisites, and no mention of alternatives. The overlap with mark_read (and, for archived/pinned metadata, with list_chats filtering) is left entirely to inference, which is risky for an agent choosing between these 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?

Annotations already declare readOnlyHint=false, destructiveHint=true, idempotentHint=true and openWorldHint=true, so the safety profile is covered structurally. The description adds the admin-permission requirement and the set of mutated fields, but does not clarify what is destructive or how unspecified fields are treated.

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 lists the mutable fields first and the admin requirement last, with no padding. It is front-loaded and wastes no words, though the field enumeration could be tighter.

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 the annotations cover the mutation/idempotency profile. The description plus schema cover most of the nine parameters, though it omits any note on leave-unchanged semantics for the optional null defaults.

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 78%, so most parameters are already documented in the schema. The description adds a loose field-level mapping ('nom', 'description', 'qui peut écrire', 'messages éphémères', 'photo' → name/topic/announce/ephemeral/photo_path), which helps semantic alignment but adds no format or syntax detail 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 specific verb ('Modifie') on a specific resource ('un groupe') and enumerates the mutable properties (nom, description, permissions d'écriture/modification, approbation des membres, messages éphémères, photo). This clearly separates it from read-only siblings like get_chat, though it never explicitly contrasts itself with update_chat or update_group_participants.

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 supplies a real precondition ('Il faut en être administrateur'), which tells the agent when the call is eligible. However, it gives no guidance on when to prefer this over update_chat or update_group_participants, so the sibling-routing decision is left 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?

Annotations already declare destructiveHint=true, idempotentHint=true, and openWorldHint=true, so the safety profile is covered. The description adds that results are reported per-person, which is extra context, but discloses nothing about permissions, partial failures, or limits beyond what annotations and the output schema provide.

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 compact sentences, with the action verbs front-loaded and the result note trailing. Every clause earns its place and there is no 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?

With an output schema present, return values need not be explained, and annotations cover the safety profile. However, the chat and account parameters remain undocumented anywhere, and no failure or permission semantics for a destructive batch operation are given, leaving noticeable gaps.

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

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

Schema coverage is only 50%, and the undocumented parameters (chat, account) are not explained in the description. The description merely restates the four action values (add/remove/promote/demote) that the schema enum already carries, so it does not compensate for the coverage 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?

The description states a specific set of verbs (ajoute, retire, nomme administrateur, rétrograde) applied to a clear resource (membres d'un groupe). An agent can distinguish this from update_group (settings) or create_group (creation) 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 describes what the tool does but gives no when-to-use guidance, no prerequisites, and no exclusions relative to siblings such as handle_join_requests, leave_group, or update_group. Usage is left entirely to inference.

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