Simafri Suite

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

With no annotations, the description carries the full burden and does well: it explains that an alias has no password, seat, or storage of its own, that mail threads in the target box and counts against its storage, and that the number of aliases is capped. It does not mention permission requirements or what a successful response looks like.

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

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

Two dense but well-structured sentences with no filler; the core behavior is front-loaded before the operational constraints, and every clause adds information an agent would otherwise have to infer.

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

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

For a two-parameter, no-output-schema tool with full schema coverage, the description supplies the behavioral model (storage accounting, alias limits, no seat/password) that the structured fields lack. Missing only auth/permission expectations and return-value confirmation.

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

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

Schema coverage is 100%, with both 'alias' and 'address' fully documented including the refusal conditions and a support-queue exclusion. The description itself adds no parameter-level detail beyond what the schema already provides, so 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?

States a specific verb ('points another address at a mailbox') and the exact resource, with an explanation of the mechanism (mail lands, threads, counts against storage). It is clearly distinguishable from remove_mailbox_alias and from add_mailbox_holder, which creates a mailbox rather than an alias.

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 directs the agent to list_mailboxes for the alias limit and current usage, which implies a check-before-add workflow, and the schema adds the constraint that a support queue is not a mailbox. There is no explicit when-not guidance or step-by-step prerequisite sequence.

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

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

With no annotations, the description carries the full burden and does disclose real behavior beyond the name: the grant is 'recorded' (audit trail), the holder list is visible to everyone on the box, and a box may have several holders. It still omits required permissions and error/reversibility details.

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

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

Three front-loaded sentences, each conveying a distinct point (effect, use case/audit, multi-holder). Slightly dense phrasing ('a person of the account') but 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?

No output schema and only two fully documented parameters, and the description covers the mutation's side effects (recorded, visible to holders). The main gap is absence of permission/authorization requirements for access-granting, which matters for a security-relevant mutation.

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

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

Schema coverage is 100% and both parameters are richly documented (person = sign-in address, address = mailbox with example and pointer to list_mailboxes). The description adds no parameter detail beyond the schema, so baseline 3 is appropriate.

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

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

States a specific verb and resource (puts a person on a mailbox) and explains the mechanism: it is 'what lets them read it.' That makes the effect clear, and the input schema separates the mailbox address from queue addresses. It doesn't name sibling tools like add_mailbox_alias or remove_mailbox_holder in the description 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?

Gives one concrete use case (reclaiming correspondence of someone who has left) which implies when to use it, but offers no explicit when-not guidance and no named alternatives. The agent has to infer that remove_mailbox_holder is the inverse.

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

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

With no annotations, the description carries the full behavioral burden and does so thoroughly. It discloses visibility in get_conversation, internal-only delivery semantics, non-mutation of status/list position, signature behavior, character limits, attachment persistence, and bulk-call result semantics including partial success and failure handling.

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

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

The description is front-loaded with the purpose and internal-only nature, then moves through visibility, usage, side effects, attachments, and bulk behavior. It is long but mostly justified by the tool's complexity; a few points, such as the character limit, are repeated from the schema, and the single dense paragraph could be better structured.

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

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

There is no output schema and no annotations, so the description must explain behavior and return-adjacent semantics. It covers what the note is, where it appears, what it does not affect, how signatures work, attachment behavior, limits, and bulk result handling, which is sufficient for correct invocation.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds useful meaning beyond the schema: attachments are for the team only, are named exactly as for reply_to_conversation, stay with the note, and appear in files; conversation_id can be a list, and the description explains the bulk results shape and partial-success 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?

The first sentence gives a specific verb and resource: it leaves an internal note on a thread for the people who work it. It clearly distinguishes the tool from reply_to_conversation by stating the note never reaches the correspondent, and it distinguishes it from status-changing siblings by saying it does not change thread status or list position.

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

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

The description gives clear usage context: handoff notes, findings, agreements, and reasons for stopping. It also gives important exclusions, such as not being sent, not being quoted in a reply, not changing status, and not affecting list placement. It does not explicitly name reply_to_conversation or set_conversation_status as the alternatives to choose when those actions are intended, so it falls short of a full when/when-not/alternative routing statement.

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

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

With no annotations, the description carries the behavioral burden well: it explains that the person sees only that queue's threads and that privileged ranks are refused. It does not cover caller permissions, idempotency, or error responses, but the key access semantics are disclosed.

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

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

The core action is front-loaded, and the three sentences each add useful context about access scope and the refusal case. There is 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?

For a two-parameter mutation tool with no output schema or annotations, the description covers the important behavioral effects and a notable edge case. It could say more about return behavior or what happens when the person is already an operator, but it is largely complete.

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

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

Schema description coverage is 100%, so both parameters are already documented thoroughly, including the queue-vs-mailbox distinction and how to find queue addresses. The description adds account-level context but does not add parameter-specific details 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 action and resource: naming a person on a helpdesk queue so they can work its threads. It also explains the access effect, making the tool's purpose clear without needing to inspect 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 gives clear situational context for using the tool: splitting a shared queue between colleagues by department. It does not explicitly name alternatives such as add_mailbox_holder or remove_queue_operator, though the schema covers the mailbox distinction.

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

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

With no annotations, the description carries the full burden and does substantial work: it discloses the key non-obvious side effect (no queue is created, threads appear only on queues the person already works), the precondition that deactivated accounts are refused, and that rank is irrelevant. It omits idempotency (what happens if the person is already a member), required permissions, and error 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?

Three short sentences, front-loaded with the action and followed by the behavioral consequence and the precondition. Every sentence carries information; only the slightly convoluted phrasing of the queue sentence costs it a point.

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

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

For a two-parameter mutation with no annotations and no output schema, the description covers the action, the visibility side effect, and the refusal condition — enough for an agent to call it correctly. It could still say what a successful call returns or how duplicates are handled, which keeps it from a 5.

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

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

Schema description coverage is 100%, so both parameters are already documented in the schema (team slug, sign-in email) and the baseline of 3 applies. The description adds only the loose notion of "a person of the account," which marginally reinforces that person is an account identity rather than a mailbox, but adds no format or constraint 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?

States a specific verb and resource ("Puts a person of the account in a team") plus a scope qualifier ("whatever their rank") that rules out permission-based refusals. It also separates the tool from the adjacent concern by noting that queue membership is decided elsewhere. It stops short of naming remove_team_member as the inverse operation, so it is clear but not fully sibling-differentiated.

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 opens no queue... which add_queue_operator decides" effectively routes the agent: use this tool for team membership, add_queue_operator for queue visibility. "A deactivated account is refused" gives a precondition that selects against use. No explicit "do not use when" statement or named inverse tool, so it falls short of a 5.

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

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

With no annotations, the description does real work: it discloses that the draft retains its original wording while the sent message keeps what actually left, so the two remain comparable. It omits whether sending is irreversible, whether the draft is removed afterward, and any permission requirements, which are meaningful gaps for a send mutation.

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 repetition of schema content. The closing clause ('so the two stay comparable afterwards') is slightly opaque but still earns its place by explaining the persistence semantics.

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 send mutation with no annotations and no output schema, the description covers the draft/body relationship but says nothing about what comes back, error behavior, or send irreversibility. It is adequate but leaves an agent guessing on important post-condition details.

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

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

Schema coverage is 100% and the schema already documents body, status, draft_id, and the attachment forms in detail. The description adds only marginal context about the body field ('the text as given in body when you edited it'), so 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 gives a specific verb+resource ('sends a draft to the contact') and clarifies the body-override mechanic. It does not, however, distinguish this from nearby siblings like send_email or reject_draft, so an agent must infer the difference from the name alone.

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

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

It implies when the body override applies ('when you edited it') but never states when to choose this over reject_draft, send_email, or delete_compose_draft. Usage context 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?

With no annotations supplied, the description carries the full burden and does so: it states that the transfer is of work rather than access, that the thread remains readable by the whole team, which subjects are refused and why, and exactly how bulk calls behave (per-thread results, succeeded/failed counts, partial success, error only when all fail). That is far beyond what any structured field conveys.

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?

Purpose and the work-not-access distinction are front-loaded, and every paragraph covers distinct ground (preconditions, exclusions, team semantics, bulk semantics). It is dense and slightly run-on, with a few rhetorical clauses that could be trimmed, but nothing is filler.

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

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

For a mutation tool with no annotations and no output schema, the refusal conditions and bulk response shape are covered well. The return value of the single-id form is not described, which is the one remaining gap an agent might want before formatting its answer.

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

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

Schema coverage is 100%, so baseline would be 3, but the description adds meaning the schema does not: that 'team' is used in place of 'person' and taken from list_teams, the 50-id cap's purpose as a single-call replacement for looping, and that one bad id does not abort the rest.

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?

A specific verb (assign) plus resource (conversation/thread) with an explicit scope limitation: it works on helpdesk queue threads, not mailbox threads. It also distinguishes the assignment (work, not access) from unassign_conversation and add_queue_operator by name, so the agent can place it among its siblings without opening a 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?

Explicit preconditions are stated (the assignee must already work the queue or be added with add_queue_operator; teams need at least one operating member), explicit exclusions are stated (deactivated accounts, mailbox threads, teams with no queue members), and the alternative for reverting is named (unassign_conversation). It also tells the agent when to use the list form of conversation_id instead of looping.

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

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

No annotations are provided, so the description carries the full behavioral burden. It clearly discloses side effects (nothing sent, message becomes an unsent draft with recipients/text/files), return information (draft_id), and the failure condition; missing permission/auth details keep it from 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?

Three compact sentences, front-loaded with the action and outcome. The parenthetical about delete_compose_draft is efficient and earns its place.

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

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

For a low-complexity one-parameter mutation with no output schema, the description covers the outcome, returned draft_id, failure mode, and alternative behavior. 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?

The sole parameter is fully documented in the schema at 100% coverage. The description does not add syntax or format meaning beyond the schema, so the baseline of 3 is appropriate.

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

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

States a specific action ('Calls a scheduled message back') and resource, with timing scope ('before it leaves') and an explicit contrast to delete_compose_draft. An agent can readily distinguish this from list_scheduled_sends or send_email.

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 usage window and exclusion: use before the message leaves, and it is refused once already leaving. It names delete_compose_draft as an alternative for discarding, though it does not explicitly mention list_scheduled_sends for discovering IDs, which the schema covers.

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

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

No annotations, yet the description carries the full burden well: one file per upload, single PUT only, no key/signing needed with a curl example, and a one-day lifetime. It also explains the return shape (upload_id + upload_url) since there is no output schema.

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

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

Front-loaded with the core action and the return contract, then the rationale and the curl example. Slightly long but nearly every sentence adds operational value; minor trimming possible.

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?

Despite no output schema and no annotations, the description fully covers the two-step flow, the returned identifiers, the one-PUT/one-file/one-day constraints, and how to hand off to sending tools. An agent can invoke it correctly from this alone.

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

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

Schema coverage is 100%, so both filename and content_type are already documented; the description largely restates the fixed-filename rule and adds little new about these two parameters. Baseline 3 is appropriate given the schema does the heavy lifting.

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

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

States a concrete verb+resource ('opens an address to send a file to') plus the mechanism (upload_url + upload_id). Distinguishes itself from the inline base64 attachment path and from the sending siblings.

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?

Explicitly says when to use it (attaching a real document, since base64 overruns for multi-page PDFs) and names the exact siblings that consume the upload_id (send_email, reply_to_conversation, forward_conversation, approve_draft). Nothing 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?

With no annotations, the description carries the full burden, and it delivers the most surprising trait: an existing address returns the existing contact rather than erroring, so the call is idempotent/upsert-like. It does not disclose permissions required, what happens to supplied fields when a matching contact is found, or what the response contains — meaningful gaps for a 9-parameter write.

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 sentences, zero waste, with the core purpose first and the idempotency consequence second. Nothing is padded or restated.

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 9-parameter creation tool with no annotations and no output schema, the description covers purpose and idempotency but leaves the key operational question unanswered: if the address already exists, are the other eight supplied fields applied, merged, or discarded? An agent cannot predict the outcome of a duplicate call with populated optional fields.

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

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

Schema coverage is 100%, so all nine parameters are already documented in the schema, and the description only echoes that the email identifies the fiche. That echo is useful but adds little beyond the schema's own wording; 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?

States a specific verb ('opens a fiche') and resource (contact), and scopes it to 'before any exchange has happened', which tells an agent this is a pre-interaction contact creation rather than an update after correspondence. It never names get_contact/update_contact as the alternatives, so sibling differentiation relies on the tool name rather than the prose.

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?

'Before any exchange has happened' gives a clear triggering context, and the idempotency note tells the agent it's safe to call without first checking existence. Missing is guidance on when to prefer update_contact or get_contact instead of re-calling 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?

With no annotations provided, the description carries the full burden and does well: it discloses visibility to every mailbox holder in webmail and mail clients, plus naming constraints such as forbidden characters, neighbor uniqueness, and exclusion of default top-level names. It omits error behavior, permission requirements, and return details, but covers the key side effects and restrictions for a create mutation.

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

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

The description is front-loaded with the core action and then adds visibility and naming rules in compact sentences. Every sentence contributes useful information, though the final clause about the six default mailbox folders is slightly dense and requires interpretation.

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 three-parameter create tool with full schema coverage, no output schema, and no annotations, the description supplies the important behavioral context: visibility, naming constraints, and placement. It does not cover return values or failure modes, but the essential information needed to call the tool correctly is present.

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

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

Schema description coverage is 100%, so the baseline is 3, but the description adds meaningful validation for the name parameter beyond the schema's 200-character limit: no "/", "*", or "%", uniqueness among neighbors, and top-level default-name restrictions. It also reinforces that parent_id controls whether the folder is top-level or nested.

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: "Makes a folder in a mailbox," and clarifies placement at the top or under another folder. It does not explicitly distinguish this create operation from siblings like update_folder, delete_folder, or list_folders, 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?

The phrase "to file threads in" implies the intended use, and the placement options are clear. However, there is no explicit guidance on when to choose this tool versus update_folder, delete_folder, or list_folders, and no prerequisites such as required permissions are stated in the description.

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

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

With no annotations, the description carries the full burden, and it does disclose key behavior: the doc is read by Iris before drafting and persists across future drafts. It does not cover failure modes (duplicate title, invalid brand slug), permission requirements, or what the call returns.

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 sentences, zero waste. The core action and scope come first, and the use-case guidance follows immediately.

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

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

For a five-parameter create tool with a fully documented schema and no output schema, the description supplies purpose, persistence, and consumer (Iris). The remaining gap is duplicate-title/error behavior, which is only hinted at in the schema.

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

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

Schema coverage is 100%, so each parameter is already documented, including the empty-list fallback semantics for brands and addresses. The description reinforces the scoping model but adds no syntax or format detail beyond the schema, so 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?

States a specific verb and resource: adding a doc to the playbook that Iris reads, with explicit scoping to brands and addresses. This clearly separates it from list_knowledge/update_knowledge/delete_knowledge by virtue of being the creation path, though it never names those siblings.

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 when-to-use examples — a price list, a proven argument, a rule to follow — and the framing 'once, where every future draft will find it' signals persistence versus one-off notes. No explicit exclusions or pointer to update_knowledge for edits, so it stops short of a 5.

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

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

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses that the slug is derived from the name and never changes, and that near-duplicate names are refused, but it does not cover permissions, return behavior, or visibility of the created team.

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 three concise sentences with no wasted text. The core behavior and the most important constraint are front-loaded, followed by the next-step guidance.

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

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

For a simple one-parameter creation tool with no output schema or annotations, the description covers the essential behavior and a key constraint. It could still mention success behavior or permissions, but it is largely complete for the tool’s complexity.

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

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

Schema coverage is 100% for the single name parameter, so the schema already defines its type and length. The description adds meaningful semantics beyond the schema by explaining that the name determines the immutable slug and must be sufficiently distinct from existing account team 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 uses a specific verb and resource: it says the tool opens a team by name. It also points to add_team_member for the follow-up action, though it does not explicitly distinguish create_team from siblings like list_teams, rename_team, or delete_team.

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 creation context and the note to use add_team_member for adding people. However, there is no explicit guidance on when to use this versus list_teams, rename_team, or delete_team, and no mention of prerequisites or exclusions.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses the consequence ('nothing was ever delivered, so nothing is lost but the text itself'), which tells the agent this is a low-stakes destructive action, but it never states whether the discard is permanent/irreversible or what happens if the draft was already sent.

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

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

Two short sentences with the action front-loaded and no repetition of the schema. The second sentence is mild reassurance rather than specification, but it does earn its place by conveying non-destructiveness.

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

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

For a single-parameter delete tool with no annotations and no output schema, the description covers what is removed and how consequential it is, which is the core need. It remains silent on irreversibility and failure modes (e.g., deleting a draft that has already been sent), which is the gap keeping it at minimum-viable.

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

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

Schema coverage is 100% and the schema description already explains that draft_id comes from list_compose_drafts, so the baseline of 3 applies. The prose adds no additional meaning about the parameter beyond what the schema documents.

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?

A concrete verb ('throws away') applied to a specific resource ('a message that was started and will not be sent'), which reads unambiguously as discarding an unsent compose draft. It does not explicitly name or contrast with siblings such as save_compose_draft, list_compose_drafts, or cancel_scheduled_send, so differentiation comes from the tool name rather than the text.

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

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

The phrase 'will not be sent' implies the triggering condition (an abandoned draft), but there is no explicit when-to-use rule and no routing to alternatives — an agent must infer that drafts to be kept should go to save_compose_draft and that draft ids come from list_compose_drafts.

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

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

With no annotations, the description carries the full burden and discloses the critical destructive traits: permanence ('FINAL and there is no trash'), exact scope of deletion (messages, drafts, files, bytes), and what remains (contact fiche and other correspondence). It does not mention authorization requirements or failure behavior, but covers the core irreversible impact.

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 opening sentence is front-loaded with the core action and scope. Subsequent sentences each add distinct value: irreversibility, the safer alternative, a usage condition, and what persists. Slightly longer than strictly necessary but no sentence is wasted.

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

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

For a destructive tool with no annotations and no output schema, the description covers the essential context: what is destroyed, permanence, alternative behavior, and when to invoke it. It omits operational details like authentication needs or error handling, but those are less critical for selecting and calling the tool correctly.

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

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

Schema description coverage is 100%, so the schema already documents the single parameter. The description adds no additional meaning about conversation_id beyond the schema's own note ('as list_conversations gives it'). Baseline 3 applies when the schema does the heavy lifting.

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

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

States a specific verb ('Deletes') and resource ('a thread and everything it holds'), and explicitly distinguishes itself from the sibling file_conversation, which is for reversible trashing. An agent can immediately tell what the tool does and how it differs from alternatives.

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

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

Explicitly says when NOT to use it ('not the gesture for tidying an inbox'), names the alternative ('file_conversation with "trash" is'), and provides a clear condition for use ('only when the record itself must not remain, and when the person asking knows that is what they are asking for').

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

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

With no annotations provided, the description carries the full behavioral burden and does so well: it discloses that subfolders are included, threads go to Trash, contents remain readable and restorable for 30 days, nothing is permanently deleted, and the response reports how many items were moved.

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

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

Three short sentences, front-loaded with the deletion scope, followed by the most important behavioral consequence and the return-value note. There is no wasted 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?

For a simple one-parameter deletion tool with no output schema, the description covers the essential behavior: cascade deletion, soft-delete semantics, restoration window, and response summary. An agent has enough information 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 coverage is 100% and the single folder_id parameter is already documented in the schema as coming from list_folders. The description adds no additional parameter semantics beyond what the schema provides, 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 states a specific verb and resource: it deletes a folder and its subfolders. It also clarifies the cascade behavior, making it clearly distinct from create_folder, update_folder, and list_folders.

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 deletion action and the clarification that the operation is reversible, but the description does not explicitly compare this tool with alternatives such as update_folder or delete_conversation. An agent can infer when to use it, but no exclusions or routing guidance are provided.

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

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

With no annotations, the description carries the burden well: it discloses irreversibility ('FINAL'), absence of recovery ('no trash'), cascading deletion of all versions, and when the effect takes hold ('Iris stops reading it from the next draft on'). It does not mention permission requirements or what happens with an invalid/stale doc_id, which is the remaining gap.

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

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

Three tight sentences, front-loaded with the destructive consequence, then the recovery caveat, then the alternative. No filler and nothing that restates the title.

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

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

For a one-parameter delete with no output schema and no annotations, the description covers the information an agent needs to decide and act: destructiveness, scope, timing, and the safer alternative. Missing only error/permission behavior, a minor gap at this complexity.

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?

Only one parameter and schema description coverage is 100%, with the schema itself explaining the id comes from list_knowledge. The description adds no parameter-level detail, 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?

States a specific verb+resource ('takes a doc out of the playbook') and immediately qualifies the scope: every version the doc ever had. It is unmistakably distinct from update_knowledge and from create_knowledge, which appear in the sibling list.

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

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

Explicitly routes the agent away from this tool when the intent is merely stale content: 'A doc that is merely out of date is better rewritten with update_knowledge.' That names the alternative and the condition selecting it, which is the strongest form of 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?

With no annotations at all, the description carries the full burden and does: irreversibility ("It cannot be undone"), a cascade side effect on attached files, an authorization rule (author, manager, account owner; anyone else refused), and a batch-size constraint ("One note at a time"). These are exactly the traits an agent needs before calling a destructive tool.

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

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

Front-loaded with the action and its blast radius, then consequences, then permissions. The colon appositive ("the files it carried with it: a note left on the wrong thread...") is slightly tangled, but no sentence is filler.

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

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

For a two-parameter destructive tool with no annotations and no output schema, the description covers side effects, irreversibility, and authz. Only the return/confirmation behavior is unstated, 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 description coverage is 100% and both parameters are documented there with provenance hints (get_conversation, list_conversations). The description adds no syntax or format detail beyond the schema, so 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?

Specific verb plus resource ("Deletes an internal note from a thread") with an extra scope disclosure that the files attached to the note are deleted too. It is unmistakable against siblings like update_note or add_note.

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 when-to-use cases ("a note left on the wrong thread, or one that is no longer true") and names the alternative for the common near-miss case: "to fix a word, update_note keeps the note." The boundary between delete and update is explicit.

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

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

With no annotations to lean on, the description carries the full burden and does disclose the non-obvious side effect: threads the team held return to their queue unassigned, while threads already taken by a member stay attributed to that member. That is genuinely useful behavioral context an agent cannot get from the schema. It still omits irreversibility, permission requirements, and whether team members are removed or whether deletion fails on a non-empty team.

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

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

Two short sentences with zero filler; the core action is front-loaded and the remaining sentence is entirely non-redundant side-effect 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 destructive one-parameter tool with no annotations and no output schema, the description explains the data-reassignment consequence well but leaves out permanence, prerequisites/permissions, and failure modes. Adequate but with clear gaps for an irreversible operation.

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

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

The single parameter is fully documented in the schema (coverage 100%), including the instruction to source the slug from list_teams. The description adds no further semantics beyond that, 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?

States a specific verb and resource ("Deletes a team"), which an agent can distinguish from siblings like rename_team, create_team, list_teams, and remove_team_member. It does not explicitly contrast itself with remove_team_member, but the object of the operation (a team, not a membership) 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?

There is no explicit when-to-use or when-not-to-use guidance, no statement that deletion is permanent, and no pointer to alternatives such as removing individual members instead. The agent must infer from the name that this is the destructive path.

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

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

With no annotations, the description carries the full behavioral burden and does so thoroughly: it explains restorability for 30 days, that replies return threads to the inbox, helpdesk queue restrictions, status-first ordering, partial batch success, and when the call returns an error versus per-thread results. No contradictions with annotations exist because none are provided.

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

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

The purpose is front-loaded, but the description is very long and dense with parentheticals and run-on clauses. Most details are useful, yet the density makes it less concise than ideal for a five-parameter tool.

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

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

For a complex mutation tool with no output schema and no annotations, the description covers operational details, edge cases, alternatives, batch semantics, and side effects. It is complete enough for an agent to use it correctly in realistic workflows.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaningful semantics beyond the schema: it clarifies folder versus folder_id, status/deal_stage interaction, and the batch behavior of conversation_id with results and counts.

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 the specific verb and resource: filing a thread into archive, trash, inbox, or a custom folder. It explicitly distinguishes this from delete_conversation and report_spam, so an agent can identify the right tool without checking siblings.

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 detailed when-to-use guidance: trash is what deleting almost always means, spam must use report_spam, helpdesk queues refuse archive, and status/deal_stage can be set in the same gesture. It also explains batching multiple threads in one call versus one call per thread.

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

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

With no annotations, the description carries the full behavioral burden and does well: it states that only the last message is forwarded, the text is quoted under its own header, and carried files are reattached. It also discloses that the recipient's answer creates a separate thread, though it omits permissions, failure behavior, and whether the original thread is modified.

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

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

The description is two tightly written sentences with no filler, and the core action is front-loaded. The second sentence adds useful routing context without bloating the definition.

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 five-parameter mutation tool with no annotations and no output schema, the description covers the key mechanics: what is forwarded, how it is quoted, attachment handling, and the new-thread consequence. It leaves some behavioral gaps around permissions and error handling, but the essential call context is present.

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

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

Schema description coverage is 100%, and the schema already explains all five parameters in detail, including cc, bcc, note, and conversation_id. The description adds forwarding behavior but does not add parameter-specific semantics beyond what the schema provides, so the baseline 3 is appropriate.

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

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

The description uses a specific verb and resource: it passes the last message of a thread on to someone else, and it clarifies that the recipient's answer opens a new thread. That behavioral contrast distinguishes forwarding from replying and makes the tool's purpose identifiable 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 gives a concrete usage context: forwarding to the account support address is how a message reaches the support queue, and notes that this works in that direction only. It does not explicitly name alternatives such as reply_to_conversation or send_email, but the support-queue scenario makes the intended use clear.

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

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

With no annotations provided, the description carries the full behavioral burden and does so in detail: text conversion rules, image/PDF/office/archive handling, macros never run, size and decompression limits, one-time 15-minute download_url behavior, and a prompt-injection warning. This is unusually rich behavioral disclosure.

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

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

The purpose is front-loaded, but the description is a very long, dense paragraph with many examples and limits. Most details are relevant for this complex tool, yet the lack of structure and repetition of format examples makes it less concise than it could be.

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?

There is no output schema, so the description must explain return behavior; it thoroughly covers text extraction, binary fallback, document.images, note fields, size limits, and download_url usage. An agent has enough information to invoke and interpret the tool correctly.

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

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

Schema description coverage is 100%, so both parameters are already documented in the input schema. The description reinforces where attachment_id comes from but adds little extra syntax or constraints for conversation_id, so the baseline 3 is appropriate.

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

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

The first sentence gives a specific verb and resource: it reads a file attached to a message and returns its content. It also distinguishes the tool from the sibling get_conversation by explicitly saying to call get_conversation to find the attachment id.

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 the prerequisite route via get_conversation, explains when to use download_url for saving, handing off, or fetching too-large files, and says to call get_attachment again for a fresh address. That is explicit when-to-use guidance with a named alternative for retrieving the attachment id.

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

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

No annotations are provided, so the description must carry the behavioral burden. 'Reads' implies a read-only operation, and it discloses that the result includes the fiche, sender addresses, and field provenance, but it does not mention permissions, error behavior (e.g. unknown contact_id), or whether any side effects exist.

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

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

The description is a single front-loaded sentence with no redundant filler. The phrasing 'whole' and 'fiche' is slightly informal but efficient; every clause contributes to scope and 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?

For a simple read tool with no annotations and no output schema, the description gives a reasonable sketch of what is returned (fiche, addresses, provenance) and implies read-only behavior. However, it leaves gaps around error handling, response shape, and any access constraints, which matters more because no output schema or annotations exist to fill them.

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 a single required parameter with 100% schema description coverage, so the schema already clearly documents contact_id and even references list_contacts. The description adds no additional meaning about the parameter, which is acceptable given the high coverage baseline.

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 ('Reads') and resource ('one contact'), and clarifies scope by saying 'one' rather than a list, which distinguishes it from list_contacts. It does not explicitly name sibling alternatives, but the singular scope is clear enough for an agent to understand its purpose.

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: 'Reads one contact whole' suggests it is the tool for fetching a single contact's full record, but there is no explicit when-to-use guidance, no mention of when to use list_contacts or search_conversations instead, and no stated prerequisites or exclusions.

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

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

With no annotations, the description carries the full burden and does so richly: it explains the exact shape of the response, clarifies that notes are never part of messages and were never sent, documents delivery states and filed_reason semantics, and describes per-thread error handling in batch mode. This is unusually thorough behavioral disclosure.

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 dense paragraph with many detailed clauses. While information-rich, it could be structured with bullets or shorter sentences for readability; some details (e.g., the full delivery-state taxonomy) are arguably more than an agent needs upfront to decide to call the tool.

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

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

There is no output schema or annotations, so the description must carry return-value explanation, which it does extensively. It is nearly complete, though it does not mention pagination or size limits on the message list, which could matter for very large threads.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value by explaining the batch outcome structure ('results', 'succeeded', 'failed') and the all-or-nothing error condition, which goes beyond the schema's simple note that a list is accepted.

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

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

The description opens with a precise verb and resource: 'Reads one thread whole: every message in order...' and enumerates exactly what is returned. An agent can distinguish this from list/search tools because it is clearly a full-thread fetch with batch support.

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

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

It explicitly says 'Read this before writing an answer' and explains that to read several threads you should pass a list of ids in ONE call rather than one call per thread. It does not name which sibling to use for finding conversation ids or when not to use this tool, but the usage context is clear.

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

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

With no annotations, the description carries the full burden and does so: it discloses that the lookup is live against an external system, enumerates all five status values with their exact meanings, and warns that "unverified" means nothing authenticates the correspondent's identity. This is materially more than the schema or annotations 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?

Front-loaded with the core action, then the status vocabulary, then the usage rule — a sensible order. The first sentence is a long nested clause chain that takes effort to parse, which keeps it from a 5, but 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?

No output schema and no annotations, yet the description covers the return shape at a useful level (account, services, renewal date, balance owed) and fully defines the status vocabulary. An agent has everything needed to call it and to interpret or abstain from the result.

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

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

Only one parameter, and the schema already documents it at 100% coverage ("The id of the conversation, as list_conversations gives it"). The description adds the useful fact that the lookup is keyed by the correspondent's address rather than the id, but says nothing further about the parameter itself, 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?

States a specific verb and resource ("reads the customer card of a helpdesk ticket") and immediately scopes it to what the account's own client area/CRM/ERP knows about the correspondent. This is clearly distinguishable from siblings like get_contact and get_conversation, which operate on stored records rather than a live external lookup.

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?

Explicitly says when to call it ("Read it before answering a customer about their account, a renewal or an invoice") and implicitly when not to act on the result, e.g. the "unverified" case warns "do not discuss their account by email". The "unavailable" case even prescribes the follow-up ("ask again later").

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

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

With no annotations, the description carries the full burden and does disclose the key trait: this is a read-only view and changes go through the support team, which prevents a fruitless write attempt. It also decodes the semantics of the own_domain_spoofs values ("filed" vs "exempt_senders"). It says nothing about permissions, auth, or how many settings are returned.

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

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

The purpose is front-loaded in the first clause, but the second sentence is a long, heavily parenthesized run-on that buries the meaning of "filed" in an aside. It is not padded with filler, yet it is denser and less scannable than it needs to be.

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

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

With no output schema and no annotations, the description must stand in for the return shape, and it only covers two settings while "starting with" implies more. It is enough to know the tool is a safe read, but not enough to know the full structure of what comes back.

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?

Zero parameters, so the baseline of 4 applies; there is no input to document. The description instead spends its words on returned-field semantics, which is the right use of space for a parameterless 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?

"Reads the settings of the account" is a clear verb+resource, and the follow-on sentences name specific settings returned (auto-draft, own_domain_spoofs). It does not name a sibling setter (set_auto_draft, set_signature) explicitly, so differentiation is by implication rather than by reference.

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 line "It is read here, and the support team changes it on request" usefully tells the agent this account-level setting cannot be mutated through any tool, which is a real usage constraint. However, it never states when to call this tool versus list_mailboxes, list_brands, or the other list_* reads, so selection guidance 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?

With no annotations, the description carries the full burden and does: link lifetime of seven days, single use, never displayed in the response, re-invocation invalidates the previous link, and multiple refusal conditions. This is exactly the behavioral context an agent needs before calling a side-effecting tool.

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

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

The critical facts (what it does, link lifetime, send_to meaning) are front-loaded, but the prose is dense and uses oblique metaphors — 'held at the shop', 'the box of whoever sets up the team's access' — where plain terms would be clearer. It runs long for the amount of structure it provides.

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 5-parameter, no-annotation, no-output-schema mutation tool, the description covers prerequisites, refusal cases, plan and role limits, re-invite semantics, and what the caller will and will not see. Nothing an agent needs to call it safely is absent.

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

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

Schema coverage is 100%, so the baseline is 3, but the description earns more: it explains that send_to must be an address the person already reads or the access-setter's box, and that 'name' is for somebody new. The platform-mailbox acceptance rule for send_to is genuine added meaning 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 makes clear that this tool invites a person to the account and creates passwordless access, so the verb and resource are identifiable. However, it never names its near siblings (add_team_member, add_queue_operator, add_mailbox_holder), so an agent must infer that this is the 'new person login' route rather than the existing-member route.

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?

Exclusions are unusually explicit: refused for someone who already chose a password, refused for a platform mailbox nobody signs in to, refused for support queues, only on accounts not held at the shop, never above manager. What is missing is positive routing — the description never says 'use add_team_member instead when the person already exists', leaving alternative selection to inference.

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

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

With no annotations, the description carries the full burden; it discloses sort order ('most recently blocked first') and that each entry includes the day blocked, which is real behavioral value. It never states that this is a read-only operation, whether results are paginated or capped, or what permissions are needed to see account-level blocks.

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 sentences, front-loaded with the concrete result and ordering, then a short justification for why the list matters. The second sentence leans slightly rhetorical ('a rule the account is living under becomes visible again') but still conveys the deleted-thread edge case.

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?

Zero parameters and no output schema, so the description must explain the return set itself — it does: addresses, sort order, and the blocked date. Only paging/limits and the read-only nature are left unstated, which are minor for a simple list tool.

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

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

The tool takes no parameters, so there is nothing for the description to clarify and the baseline of 4 applies. Nothing in the text misdescribes the (empty) input surface.

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 and resource ('Lists the addresses whose mail this account files straight into Spam') and ties the concept to report_spam's output, so an agent knows exactly what it gets. It stops short of distinguishing the list from close siblings such as list_suppressed_recipients or list_sender_addresses, which are the realistic confusion points.

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 framing ('this is where a rule the account is living under becomes visible again') implies when the tool is useful, especially for blocks surviving deleted threads. But there is no explicit when-to-use/when-not against siblings like list_suppressed_recipients or unblock_sender, so the agent must infer the 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?

With no annotations present, the description must carry behavioral weight; it discloses that the result is account-scoped and includes subdivisions, and that each item exposes a slug. It says nothing about ordering, pagination, permissions, or behavior on an account with no brands.

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 slightly under-polished in wording ('its subdivisions, each with the slug'), which costs a point but not comprehension.

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-argument list tool with no output schema, the description should convey the return shape; it does mention brands and their slugs but omits ordering, volume, or whether nested subdivisions form a hierarchy. Adequate but leaving real gaps.

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

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

The tool takes zero parameters, so there is nothing to disambiguate and the baseline of 4 applies. The description correctly implies a no-argument, whole-account enumeration.

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 (lists brands) and scopes it to 'the account, its subdivisions', which distinguishes it from the other list_* siblings like list_teams or list_mailboxes. The trailing clause 'each with the slug the other tools take' is grammatically awkward but still informative about the payload.

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

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

The phrase 'the slug the other tools take' implicitly tells an agent to call this first to obtain a brand slug before invoking other tools. There is no explicit when/when-not framing or named alternative, so the guidance is implied rather than stated.

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

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

With no annotations, the description carries the full behavioral burden. It discloses ordering ('last written first') and return fields ('recipients, subject, text and files'), which are useful traits beyond the name. It does not mention pagination or limits, so it is strong but not fully complete.

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 sentences, both front-loaded and purposeful. The first states scope, ordering, and return contents; the second handles sibling differentiation, with no wasted 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?

For a list tool with no output schema and no annotations, the description does well: it states what is returned and in what order, and distinguishes it from list_drafts. It omits pagination or volume behavior, which is a remaining gap given the absence of structured annotation help.

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

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

The single optional address parameter is fully documented in the schema, including that it comes from list_sender_addresses. The description does not add parameter-specific meaning beyond the schema, 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 uses a specific verb-resource pair ('Lists the messages begun... and never sent') and adds precise scope: account addresses, unsent, last-written-first. It explicitly distinguishes this from the sibling list_drafts, so an agent can tell which list tool to choose.

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

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

It explicitly names the alternative, list_drafts, and explains the difference: 'unsent texts, not the answers Iris wrote for review.' That is a direct when-to-use-this-vs-sibling cue, leaving little inference for an agent.

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

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

No annotations are provided, but the description is read-only by implication and discloses useful behavior such as result ordering (most recently seen first) and the fields searched. It does not describe return structure, pagination behavior, or permissions.

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 well-packed sentence with the key behavior front-loaded. It is appropriately sized, though the phrase 'with their fiche' is slightly ambiguous and could be clearer.

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

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

For a simple read-only list tool with no output schema, the description covers listing, ordering, and search fields. It leaves the return format and what 'fiche' includes unspecified, which is a gap given there is no output schema.

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

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

Schema coverage is 100%, so both parameters are already documented. The description only reinforces that search matches name, company, and address; it adds no syntax or format details 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?

States a specific verb (lists/searches) and resource (contacts of the account), plus ordering and search fields. It clearly differs from get_contact or create_contact, though it does not explicitly differentiate from list_people or other list tools.

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 purpose: use it to list or search contacts. There is no explicit guidance on when to prefer this over siblings like list_people or get_contact, nor any when-not conditions.

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

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

With no annotations, the description carries the full burden and does well: it discloses ordering, defaults, null semantics for team_subject/ticket/waiting_since, and an operational quirk ('A key that acts for no person has no read state and is told so rather than answered with a list built for nobody'). It does not mention pagination ceilings beyond limit or performance/rate characteristics, 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?

Front-loaded with purpose, then the default-box behavior, then the box-less alternative – a sensible order. The first sentence is a long run-on enumerating returned fields, which is justified given there is no output schema, but it costs 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?

Eleven optional parameters, two modes, and no output schema – the description compensates by describing the returned fields, the pagination cursor trick via updated_at, defaults, and null cases. An agent has everything needed to call this correctly and to know what it will get back.

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

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

Schema coverage is 100%, so the baseline is 3, but the prose adds real meaning beyond the schema: it explains the box/folder/unread interaction as a single viewing mode versus the status-driven account mode, and it frames waiting_since/last_reply_at as the pair a helpdesk queue is watched by. That context is not derivable from the individual property descriptions alone.

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?

Opens with a specific verb and resource ('Lists threads, most recently updated first') and enumerates the shape of what comes back. It separates the two listing modes clearly, though it never names the closest sibling (search_conversations) so the agent must infer that this is the browse-all tool.

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

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

Explicitly states the when-and-how: name a 'box' to read one mailbox screen-by-screen, omit it to read the whole account by pipeline status, and explains why these are different questions ('a thread sitting unread in a mailbox has a status like any other'). It also names the helper tools for finding inputs (list_sender_addresses, list_teams, list_brands, list_folders, list_people) and flags mutual exclusions with 'box'.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses the returned fields and filter semantics, but it omits pagination, ordering, permissions, and the read-only nature of the operation, leaving meaningful behavioral gaps for a list tool.

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

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

The description is two compact sentences, front-loads the purpose, and mentions the returned fields and review-queue filter without unnecessary wording. Every sentence contributes useful 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 simple one-parameter list tool with no output schema, the description covers the resource, returned fields, and the main filter. It does not describe pagination or ordering, but those omissions are minor for this tool's complexity.

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 status parameter enum is fully documented in the schema. The description reinforces the key "pending_review" value but adds little beyond the schema, so the baseline of 3 is appropriate.

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

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

The description states a specific verb and resource: it lists the answers Iris has written, and it enumerates the returned fields (thread, contact, text). It does not explicitly distinguish itself from the sibling list_compose_drafts, 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?

It gives a clear usage cue: filter on "pending_review" for the review queue. That is actionable context, but it does not say when to use this tool instead of related siblings such as list_compose_drafts or approve_draft.

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

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

With no annotations, the description carries the burden and does reasonably well: 'Lists' implies a read-only operation, the six implicit folders are disclosed so the agent isn't surprised by pre-existing entries, and the hierarchical nature (full path, parent) is surfaced. It omits ordering guarantees and whether custom folders can nest arbitrarily, which keeps it below 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?

A single dense sentence front-loads what the tool returns, with the id-consumer clause tacked on for routing. Every clause carries information, though the sentence is long enough that splitting the returned-fields list from the id-consumption note would read more cleanly.

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?

There is no output schema, yet the description effectively documents the return shape (id, name, full path, parent) and explains where those ids are consumed. Combined with a single fully-documented parameter, an agent has everything needed to call this 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?

Only one parameter and schema coverage is 100%; the schema already documents the 'box' argument, including the pointer to list_sender_addresses and the queue caveat. The description adds nothing about the parameter, 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?

States a specific verb and resource ('Lists the folders ... of a mailbox') and immediately scopes it: the six default folders plus user-created ones. It even enumerates the returned fields (id, name, path, parent), so the agent knows exactly what it gets without opening a 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 routes the agent by naming the downstream consumers of the returned ids (list_conversations, search_conversations, file_conversation, update_folder, delete_folder), which implicitly tells it to call this first when folder identity is needed. It stops short of an explicit 'use this before X, not Y' statement, and the negative case (a support queue has no folders) lives in the schema rather than the description.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the operation returns full document content, which is useful behavioral context for potential response size, but it does not cover permissions, pagination, or other operational constraints. 'Lists' implies a read-only operation, so there is no contradiction.

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

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

The description is a single front-loaded sentence with no wasted words. The idiomatic phrase 'what the house does' is slightly informal but still earns its place by conveying intended use.

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 list tool with no output schema, the description is complete enough: it states what is returned (full content) and when the data is useful. Minor operational details like pagination are absent but not critical for correct invocation.

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

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

The tool has zero parameters, so there is no parameter semantics for the description to compensate for. The baseline of 4 applies.

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

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

The description uses a specific verb and resource: 'Lists the playbook docs of the account with their full content.' That is clearly distinct from sibling tools like list_drafts and create_knowledge, though it does not explicitly name alternatives it is not.

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 clear usage context: this is the material Iris reads before drafting and the place to look when an answer needs to describe house practices. It does not state explicit exclusions or alternatives, so it falls short of a 5.

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

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

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses what data is returned (holders, aliases, storage quota) and explicitly excludes mailbox contents, implying a read-only operation. However, it does not mention permissions, pagination, rate limits, or response ordering, leaving meaningful behavioral gaps for a tool with no 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 two sentences, front-loads the core action, and avoids unnecessary repetition. The second sentence earns its place by clarifying the metadata-only scope, though the phrasing 'which every box of it shares' is slightly awkward and 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?

For a parameterless list tool with no output schema, the description explains the key returned fields (holders, aliases, storage entitlement) and explicitly states what is excluded (contents). It is nearly complete for this complexity level, though it could mention ordering or pagination behavior for a listing endpoint.

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

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

The tool has zero parameters, so there are no parameter semantics to describe. Per the rubric, zero parameters establishes a baseline of 4; the description does not need to compensate for any schema gaps.

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 ('Lists the mailboxes of the account') and details exactly what each returned mailbox includes: holders, aliases, and shared storage entitlement. It also clarifies that it does not expose mailbox contents, which distinguishes it from conversation/message tools. However, it does not explicitly differentiate itself from the sibling poll_mailboxes.

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 scope statement 'says who is on a box, never what is in one,' which suggests the tool is for mailbox metadata rather than message retrieval. But there is no explicit when-to-use guidance, no named alternative such as poll_mailboxes, and no prerequisites or exclusions stated.

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

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

No annotations exist, so the description carries the burden. It does add real behavioral context – the rank is not writable from this tool, and for Simafri Suite clients rank is held remotely and restated at sign-in – which is genuinely useful. But it omits return shape, ordering, pagination, and permissions, leaving gaps for a no-annotation tool.

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

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

It is short, but the sentences are dense and metaphorical ('how far they see into the mail', 'held at the shop'), requiring re-reading. The key fact – that this lists people and their queue scope – is not front-loaded in plain language.

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

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

With no annotations and no output schema, the description is the only source of return-value detail; it names the fields (sign-in, rank, queue visibility) but gives no structure, ordering, or pagination guidance. Adequate to call, but not complete for interpreting results.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. The description's discussion of return fields is extra value rather than parameter semantics.

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 ('Lists everyone on the account') and enumerates what is returned: sign-in method, rank, and queue visibility. It is distinguishable from siblings like list_teams or list_contacts, but the jargon ('works_every_queue', 'the shop', 'Simafri Suite') makes the scope harder to grasp than it needs to be.

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: 'It says who works where, never what any of it holds' bounds the tool to membership/organizational data, which implicitly steers an agent away for content questions. However, no sibling is named as an alternative and no prerequisites or exclusions are given.

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

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

With no annotations, the description carries the full burden and does well: it discloses ordering, returned fields, timezone handling, and that failed sends stay visible with state 'failed' and the reason. It does not discuss pagination or permissions, but for a read-only listing tool the behavioral picture is largely complete.

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 definition is front-loaded with the core behavior and then adds only necessary lifecycle context: what has left, what failed, and when it disappears. Every sentence contributes useful information without 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?

For a no-required-parameter list tool with no output schema and no annotations, the description is quite complete: it explains return fields, ordering, timezone, and failed-send behavior. It could additionally mention pagination or result limits, but those are minor gaps for 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?

There is only one optional parameter and the schema description coverage is 100%, so the schema already explains the address filter. The description does not add syntax or selection guidance beyond the schema, making the baseline 3 appropriate.

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

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

The description states a specific verb and resource: it lists messages with a 'send_at' that have not left yet, ordered soonest first. It also distinguishes this from messages already sent, which appear in their thread rather than here, so an agent can identify the tool's scope 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 gives clear context for when this tool applies: pending scheduled messages, including failed ones that remain until cancelled. It does not explicitly name alternatives such as list_drafts or cancel_scheduled_send, but the lifecycle explanation implies when this list is the right source.

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

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

With no annotations, the description carries the full burden: the verb "Lists" weakly implies a read-only operation, and it gestures at what the response contains (address, signature block, aliases). But it never states that it is read-only, whether it requires permissions, or how results are ordered or bounded.

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 sentences, but the second is oracular shorthand that forces the reader to decode meaning rather than commit space to useful detail. The leading clause is correctly 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?

No output schema, so the description should explain the return shape; it does partially (address, closing block, mailbox aliases), but through obscure phrasing that leaves the actual field contents uncertain.

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, so there is nothing for the description to disambiguate; baseline 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 opening clause "Lists the inbound addresses of the account" gives a specific verb and resource, but the rest of the sentence is cryptic ("the block that closes what is written from it" presumably means signature, "the other names that deliver into it" presumably means aliases). It never differentiates itself from sibling list_mailboxes, which an agent could easily mistake for 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?

"Sending from any of these is what brings the answer back into the mailbox" hints at a purpose but gives no explicit when-to-use, no prerequisites, and no named alternative such as list_mailboxes. The agent must infer the selection condition.

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

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

With no annotations provided, the description carries the full behavioral burden and does so well: it discloses that sends to these addresses are stopped silently before leaving, with no bounce and nothing visible in the thread. That is exactly the non-obvious behavior an agent needs to avoid misdiagnosing a missing email.

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

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

The description is front-loaded with the list's contents, then explains the silent-blocking behavior, then ends with the diagnostic use case. Three sentences, no repetition, and every sentence adds operational value.

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

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

Given zero parameters, no output schema, and no annotations, the description is complete enough: it explains what the list contains (address, day, provider label), why it matters, and how suppression manifests to the user. An agent can select and correctly interpret this tool without further fields.

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, so there are no parameter semantics for the description to clarify. The baseline for a parameterless tool is 4, and no additional parameter guidance is needed.

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

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

The description states a specific verb and resource: it lists addresses that marked this account's mail as spam and that the account can no longer write to. The spam-specific mechanism and the 'no longer write to' scope distinguish it from generic address-listing or blocked-sender tools.

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

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

It gives a clear triggering scenario: read this list when a mail seems to have gone nowhere and nothing explained why. It does not explicitly contrast this with nearby tools such as list_blocked_senders or explain when suppression is not the right explanation, so it stops short of full 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?

With no annotations, the description carries the burden and does add real behavioral context: a team opens no queue and members only see threads of queues they work. That visibility/membership semantics is valuable and non-obvious. It stops short of saying the call is read-only and cheap, but 'Lists' implies it.

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 sentences, zero filler, and the most decision-relevant fact (the slug is what other team tools take) is packed into the first sentence. The second sentence explains semantics rather than 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?

There is no output schema, and the description compensates by naming the return fields (slug, membership). Combined with the team-vs-queue explanation, an agent has everything needed to call this and to use its results.

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

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

The tool takes zero parameters, so the baseline is 4; nothing is left undocumented. The description usefully previews what each entry carries (slug and members) rather than wasting space on parameter detail.

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 ('Lists the teams of the account') and adds concrete examples of team kinds (administrative, technical). It also defines what a team is, which distinguishes it from sibling list tools like list_people or list_mailboxes without needing to open 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?

Explicitly tells the agent that the returned slug is what assign_conversation and other team tools accept, which is a clear downstream-use cue. It does not state when not to use it or name a direct alternative, so it falls short of full routing 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?

With no annotations, the description carries the full burden and does so: it discloses the side effects (move to Inbox, unblock sender), the idempotent no-op condition, per-thread isolation on partial failure, and the exact error condition (only when none succeeded). It even documents the response shape ('results', 'succeeded', 'failed') despite no output schema.

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

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

The primary action and its main side effect are in the first sentence, with batching and failure semantics following. It is one dense block covering a lot of ground, slightly heavy but every clause is load-bearing for a batch mutation tool.

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

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

For a single-parameter batch mutation with no annotations and no output schema, nothing material is missing: side effects, no-op behavior, partial-failure handling, result ordering, and aggregation counts are all described.

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

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

Schema coverage is 100%, so baseline is 3; the description adds real value by explaining that conversation_id accepts a list and that results are returned in the order given, linking the parameter shape to observable behavior. It does not restate the 50-id cap, but the schema already does that.

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: puts a spam-filed thread back into the mailbox Inbox and unblocks its sender. This is clearly distinct from report_spam (the inverse) and unblock_sender (sender-only, no thread move), so an agent can route 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?

Gives explicit batching guidance — pass a list of ids in ONE call rather than one call per thread — which is the main usage decision for this tool. It also covers the no-op case (thread not in Spam is left alone, nothing unblocked). It does not explicitly name report_spam or unblock_sender as alternatives, which keeps it below a 5.

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

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

With no annotations, the description carries the full burden and does so: per-user read state ('a colleague reading the same shared mailbox keeps their own'), the re-bolding behavior on new mail ('A message arriving after this call turns the thread bold again'), and precise batch failure semantics including per-thread isolation and the 'error only when none succeeded' rule.

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

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

Front-loaded with the core semantic (clears bold, for you) before the get_conversation disambiguation and batch detail, so an agent gets the gist in the first clause. It is a dense single paragraph and the quoted token names add some bulk, but nearly every clause carries a distinct behavioral fact.

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?

No output schema exists, yet the description explains the shape of the batch response and the aggregate error condition, so nothing an agent needs to interpret results is missing. Combined with the per-user scoping and re-bold behavior, the definition is complete for a single-parameter mutation 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 100% and the single parameter's description already covers the string-or-list forms and the 50-item cap. The description still adds batch-specific meaning: order preservation, the 'results' array with per-item 'ok'/'result'/'error', and the 'succeeded'/'failed' counters.

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 ('Clears the bold on a thread') and immediately scopes it as per-user ('for YOU'), which distinguishes it from mailbox-wide or fetch-style siblings. It also explicitly separates itself from get_conversation, so an agent can pick correctly without reading either 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 an explicit when-not ('Reading a thread with get_conversation does not do this by itself, on purpose') and an explicit bulk-usage rule ('give conversation_id the list of their ids, in ONE call rather than one call per thread'). The condition selecting each mode is stated, not inferred.

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

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

With no annotations, the description carries the full burden and does well: it discloses personal-only scope, batching behavior, per-thread result reporting, partial success semantics, and when the call itself errors. It does not cover permissions, rate limits, or idempotency, but the behavioral picture is substantially richer than a bare verb.

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

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

The description is front-loaded with purpose, but it is wordy and relies on repeated metaphorical language ('bold rows') that could be tightened. The batch/result explanation is valuable but could be expressed more concisely without losing meaning.

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

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

For a one-parameter tool with no annotations and no output schema, the description is largely complete: it explains the action, scope, batch invocation, result format in 'results', and error semantics. The main missing piece is a brief note on when to choose this over the opposite operation (mark_read), but otherwise an agent has enough 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 100%, so the schema already documents that conversation_id accepts a string or a list of up to 50 ids. The description repeats this parameter behavior without adding syntax or format details beyond what the schema provides, so baseline 3 is appropriate.

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

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

The description states a specific action ('Puts a thread back among the bold rows') and clarifies the personal scope ('for you alone: what you want to come back to. A colleague sees no change'), which helps distinguish it from a global change. However, it does not explicitly name the sibling mark_read or contrast with it, so sibling differentiation relies on the agent's inference.

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 'what you want to come back to', and there is extensive guidance for batching multiple threads, but no explicit when-to-use versus alternatives (e.g., when to pick mark_unread over mark_read or other conversation tools). The batch advice is more about invocation than tool selection.

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

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

With no annotations, the description carries the full burden and does: it enumerates what transfers (messages, files, notes, drafts), states the old number continues to route to the surviving case, that the merged ticket is gone, that an audit note is written with the supplied reason, that a pending draft is set aside, and that the action is irreversible. That is unusually complete disclosure for a destructive mutation.

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

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

Front-loaded with purpose and effect, then constraints, with zero filler sentences. It is dense and slightly long, but every clause conveys a distinct fact an agent needs before an irreversible merge.

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?

No annotations and no output schema, so the description must supply safety, side effects, and preconditions — and it does all three, including irreversibility, the note side effect, and the queue/contact requirement. Nothing material to calling this correctly 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 100%, so baseline is 3; the description adds the disambiguating meaning of 'into' ('the ticket that stays') and a behavioral directive for 'note' — it is embedded in the merge note, so don't add a second one via add_note. That is genuine value beyond the schema, though it does not extend the identifier syntax beyond what the schema already documents.

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 ('Merges a helpdesk ticket into another') plus the binding constraint (same contact), and the scenario sentence ('client who wrote again beside their case rather than in it') pins down the distinct intent. An agent can distinguish this from delete_conversation, file_conversation, or assign_conversation without opening a 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 triggering scenario and hard preconditions: 'Both must be tickets of a support queue you can open, with the same contact; a mailbox thread is refused.' It never names a sibling alternative (e.g. file_conversation or delete_conversation) for the cases it excludes, so routing for the refused mailbox case is left implicit.

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

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

With no annotations at all, the description must carry the safety profile, and it does disclose the key behavioral trait: this forces an immediate fetch rather than waiting for the scheduled round. It does not say whether the call blocks on the mail server, whether it has side effects or rate limits, or what happens on failure — meaningful gaps for an unannotated 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?

Two short sentences, zero filler: the mechanism ('right away instead of waiting for the next scheduled round') comes first and the invocation cue second.

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?

No output schema exists, so the description should carry more of the return contract than "answers with what came in" — it is unclear whether this yields full messages, headers, or just a count/notification. For a no-parameter polling tool with no annotations, the missing return shape and blocking/failure behavior leave it only minimally adequate.

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?

Zero parameters, so there is nothing for the description to compensate for; the baseline applies. The description correctly implies no arguments are needed.

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

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

States a concrete verb (reads/polls the account mailboxes) and a concrete effect: it bypasses the scheduled round and returns what arrived. That distinguishes it from a configuration-oriented sibling like list_mailboxes, but the description never names list_mailboxes or any sibling explicitly to draw the 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?

"Call it when you expect a message that has not appeared yet" gives a clear positive trigger. There is no explicit when-not guidance (e.g., don't poll in a loop, prefer list_conversations once mail is present), so the alternative-selection side 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?

With no annotations, the description must carry the behavioral burden. It usefully discloses the key side effects—nothing is sent and the thread remains open—but omits what happens to the draft's state afterward, permissions needed, and whether rejection is reversible.

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 action and immediate consequence. Every phrase adds useful meaning, with 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?

For a simple two-parameter action with full schema coverage and no output schema, the description covers purpose and the main behavioral outcome. It could mention the draft's resulting state, but that is a minor gap given the schema already documents parameters.

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

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

Schema coverage is 100% and both parameters are documented there, including that the reason is kept with the draft. The description adds no parameter-level meaning beyond identifying the draft as the object being rejected, 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?

States a specific verb ('turns a draft down'), the resource (draft), and the critical consequence ('sends nothing'). It implicitly separates the action from approve_draft and send_email by making rejection non-sending and leaving the thread open.

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 clear context for using it: reject the draft without sending and keep the thread open for another answer. It does not explicitly name approve_draft as the alternative or state when not to use it, so it stops short of full routing 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?

With no annotations, the description usefully discloses that existing messages remain in the box and retain the alias they arrived on. However, it omits permissions, reversibility, what happens to future mail sent to the alias, and error behavior for a destructive mutation.

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 effect and then the relevant caveat about existing messages. There is no wasted 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?

For a simple two-parameter mutation with fully documented schema fields and no output schema, the description gives the key behavioral outcome and message-retention caveat. It could be more complete about prerequisites or reversibility, but the core invocation context is present.

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

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

The schema has 100% description coverage, and the descriptions explain both address and alias clearly, including pointing to list_mailboxes. The free-text description adds no parameter-specific semantics beyond that schema content, so the baseline score 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 states the concrete effect of removing a mailbox alias: an address no longer delivers into the box. It is clear but does not explicitly name 'alias' or distinguish this from nearby tools such as remove_mailbox_holder or remove_suppression without relying on the title.

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 does not say when to use this tool versus add_mailbox_alias, remove_mailbox_holder, or other removal tools. Usage is only implied by the tool name/title and the address/alias parameters.

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

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

With no annotations, the description carries the burden and does well: it discloses immediate effect, non-deletion, and that an empty mailbox continues receiving and retaining content. It omits permission requirements, idempotency, and error behavior, keeping it below 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?

The description is short and front-loaded, leading with the action and then the consequences. 'Recorded like the other direction' is slightly vague and requires inference, but the overall structure 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?

For a mutation tool with no annotations and no output schema, the description covers the key behavioral consequences an agent needs: immediate removal, no deletion, and continued mailbox retention. It could be more complete with permission/audit details, but it is substantially adequate.

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

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

Schema description coverage is 100%, so both parameters are already richly documented, including the distinction between the person's sign-in address and the mailbox address. The description itself adds no additional parameter-level meaning beyond the schema, so 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 states a specific verb and resource: taking a person off a mailbox. It is distinct from alias and queue operations by the 'person'/'mailbox' framing, but it does not explicitly name the sibling alternative add_mailbox_holder.

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 explains what the operation does but gives no explicit guidance on when to use it versus add_mailbox_holder, remove_mailbox_alias, or remove_queue_operator. The phrase 'like the other direction' only weakly implies the counterpart operation.

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

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

With no annotations, the description carries the full burden and does substantial work: it discloses that nothing is deleted, that access stops immediately ('from that moment'), and what happens to a queue that ends up with no operators. It omits permission requirements, idempotency, and the failure mode when the person is not on the 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 that leads with the action and effect, then adds the two non-obvious consequences. No filler and no restatement of the title.

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

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

For a two-parameter, non-destructive membership removal with a fully described schema, the description covers the effect, the data-safety profile, and the empty-queue edge case. Only return/confirmation behaviour and permission prerequisites are absent, which are minor here.

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 itself already disambiguates queue from mailbox and person from mailbox address. The description adds no parameter-level meaning of its own, 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?

States a specific verb and resource plus the concrete effect: 'Takes a person off a helpdesk queue: they stop seeing its threads from that moment.' An agent immediately knows what changes for the person. It does not name its inverse sibling (add_queue_operator), so sibling differentiation is left to inference.

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 use case is implied by the effect statement, but there is no explicit 'use this when' clause, no exclusion, and no pointer to add_queue_operator for the reverse operation. The clarification about a queue with nobody named on it is behavioural context rather than routing 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?

With no annotations, the description carries the behavioral burden and does well: it explains that the row means a person marked mail as spam, warns that recontacting can affect shared sending reputation, and notes that an unsuppressed address means there was nothing to lift. It does not cover permissions or whether the removal is reversible.

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

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

The purpose is front-loaded in the first sentence, followed by useful caution. The text is slightly narrative but appropriately sized for a reputation-sensitive operation, with no clearly wasted sentences.

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

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

For a single-parameter mutation with no annotations or output schema, the description supplies the important context: complaint meaning, reputation risk, when to invoke it, and what an empty suppression state implies. It could still mention permissions or reversibility, but is otherwise complete enough to call 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?

There is one parameter with 100% schema description coverage, so the schema already defines it. The description reinforces that the address should come from list_suppressed_recipients, but adds no new syntax or format semantics 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 and resource: taking an address off a suppression list so the account can write to them again. It is clear what the tool does, though it does not distinguish this operation from the sibling tool unblock_sender, which could be a related alternative.

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

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

It gives clear when-to-use and when-not-to-use guidance: call it when there is reason to believe the recipient wants to hear from the account again, not merely because a message would not leave. It does not name unblock_sender or other alternatives explicitly, so it misses the top guideline score.

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

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

With no annotations provided, the description carries the full burden. It does disclose one genuinely non-obvious side effect — conversations the person picked up from the team remain attributed to them — which is real behavioral value. However, it omits permissions required, whether the removal is reversible, and what happens if the person is not on the team.

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

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

Two short sentences with zero filler; the core action is front-loaded and the side-effect note follows immediately. Nothing could be cut 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?

Parameters are fully documented in the schema and no output schema is needed, but for an unannotated mutation tool the description should say more about authorization and reversibility. It is adequate rather than complete.

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

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

Schema coverage is 100%, and the schema descriptions are unusually rich (slug source for 'team', the email-vs-mailbox distinction for 'person'). The description adds nothing about parameters, 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?

States a specific verb and resource ('Takes a person out of a team'), which unambiguously identifies the operation. It does not name the inverse sibling add_team_member or distinguish itself from remove_mailbox_holder, leaving the agent to infer the distinction from the name alone.

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

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

Usage is only implied by the purpose statement; there is no explicit when-to-use, no prerequisites (must the person already be a member?), and no mention of alternatives such as remove_queue_operator or delete_team. An agent can guess correctly but is given no routing help.

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

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

With no annotations, the description carries the full load and does: it discloses the side effect (a note is recorded on the thread, signed by the acting person, naming the former subject), the search impact (findable by both subjects), the invariants (replies still go out as "Re:" of the original, the client keeps one conversation), and the 255-character one-line constraint.

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?

Purpose and the team-vs-correspondent distinction are front-loaded, and nearly every clause adds information. It is a single dense paragraph with some redundancy against the schema (one line, 255 characters) and slightly shifting vocabulary (thread / ticket / conversation), which costs it a point.

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

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

No annotations and no output schema, yet the description covers mutation semantics, side effects, clearing behavior, validation limits, and downstream effects on search and reply threading. An agent has everything needed 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 coverage is 100%, so baseline is 3, but the description adds real meaning: team_subject is the team's label and never the correspondent's subject, one line up to 255 characters, and re-supplying the mail subject or null clears it. It also clarifies that only one subject exists per thread, hence a single conversation_id.

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: it gives a thread a team-owned subject, and sharply contrasts that with the correspondent's mail "subject", which stays untouched. An agent can tell exactly what this does and how it differs from siblings like set_conversation_status or reply_to_conversation.

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 triggering conditions: use it on a ticket whose subject says nothing of the request, a form notification, or a bare order, once the request is known. It also explains the inverse case (re-submitting the mail subject, or null, removes the team subject), but names no sibling alternative or exclusion.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses that the slug remains unchanged and existing references keep working, but it omits permission requirements, duplicate-name behavior, and what the operation returns.

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 action and followed by the key behavioral consequence. There is no wasted 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?

For a simple two-parameter rename tool with a fully documented schema and no output schema, the description covers the core action and slug stability. However, with no annotations, it leaves gaps around permissions, conflict handling, and operational side effects.

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

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

Schema description coverage is 100%, so both parameters are already documented in the schema. The description adds no further parameter syntax or constraints beyond noting that the team's slug is stable.

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: 'Gives a team a new name.' It is clearly a rename operation rather than create/delete/list, but it does not explicitly distinguish itself from sibling tools such as create_team or delete_team.

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 explains what happens when renaming but gives no when-to-use guidance, prerequisites, or alternatives. An agent must infer that this tool is for renaming an existing team and not for creating, deleting, or listing teams.

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

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

With no annotations, the description carries the full burden and does disclose real side effects: the pending draft is superseded so the contact reads one answer, and with send_at the supersession is deferred until the answer actually departs. That is genuinely useful beyond what structured fields show. However, for an irreversible outbound-send mutation it says nothing about permission requirements, failure modes, whether a signature is appended, or whether cancelling a scheduled send is possible via cancel_scheduled_send.

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

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

Three sentences, front-loaded with the core action, then side effects, then the scheduling caveat. No filler; the slightly convoluted "supersedes that draft only when it leaves" is the only wording that costs the reader a second pass.

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 an 8-parameter send tool with no annotations and no output schema, the description covers the send path and draft interplay adequately, and the rich schema fills in parameter detail. It still leaves the agent without any notion of what comes back after sending or what happens on partial failure, which matters when no output schema exists to describe the result.

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

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

Schema description coverage is 100%, so every parameter including cc/bcc, status, send_at, and the attachment form is already documented in the schema itself. The description adds only a small amount of framing (the send_at draft-supersession interaction) rather than new parameter-level meaning, 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?

States a specific verb and resource: "Sends an answer in an existing thread, written by the caller, from the address the thread arrived through." That clearly separates it from composing a brand-new message, though it never names the sibling it competes with (send_email, approve_draft, save_compose_draft), so the distinction is inferred rather than 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?

The precondition "an existing thread" is implied by the phrase itself, and scheduled vs immediate sending is explained. But there is no statement of when to prefer this over send_email, approve_draft, or a saved compose draft, and no exclusion for threads that are closed or otherwise ineligible.

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

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

No annotations exist, so the description carries the full burden and does so: reversible move, persistent sender blocking, a 30-day retention window whose deletion is final, refusal on helpdesk queues, and partial-failure semantics where one bad id doesn't abort the rest and the call errors only when none succeed. It even describes the per-thread outcome fields, which no output schema covers.

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

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

Front-loaded with the core action and blocked into distinct concerns (effect, retention, helpdesk exclusion, batching), with no filler sentences. It is dense and long for a single paragraph, and the batch/return-shape material could be split for scanability, but the length is justified by the destructive and batch semantics it must convey.

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 one required parameter, no output schema, and no annotations, the description fills every gap an agent needs: what it changes, reversibility, a hard deletion deadline, the refusal case and its alternative, and the exact batch response semantics including partial failure. Nothing material is left to inference.

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

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

Schema coverage is 100%, so the string-or-list-of-50 shape is already documented, putting the baseline at 3. The description adds real meaning beyond that: the list form is for batching in one call, and it explains how per-element results are ordered and reported and that the call fails only if all fail.

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 and spells out exactly what happens: the thread moves to Spam, the sender is blocked, and the move is reversible. It also carves out the sibling boundary by naming file_conversation with "trash" for helpdesk threads, so the agent can distinguish report_spam from file_conversation and delete_conversation without opening schemas.

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

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

Explicit when-not guidance: helpdesk queue threads have no Spam folder and are refused, with the named alternative file_conversation("trash"). It also gives positive usage guidance for the batch case — pass a list of ids in ONE call rather than one call per thread — which is exactly the decision an agent needs to make.

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

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

With no annotations, the description carries the burden, and it does disclose two non-obvious traits: this is non-sending, and it behaves as a patch (omitted fields keep prior values, "from" is ignored after creation). It does not say what is returned (presumably a draft id), whether the draft is validated, or where drafts surface, which keeps it at a 3 for an unannotated mutation tool.

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

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

Three short sentences, front-loaded with the core action, then the mode-selection rule, then the boundary against send_email. 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?

No output schema and no annotations, with seven optional parameters, so the description must supply the operational picture — and it does for creation, updating, and the no-send guarantee. It leaves the return value and the consequence of passing neither "from" nor draft_id unstated, a modest 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 coverage is 100%, so per-field descriptions already do the heavy lifting and a 3 is the baseline. The description adds cross-parameter semantics the schema cannot express: create-vs-update mode selection via "from" vs draft_id, and merge behavior for omitted fields. That is genuine added meaning.

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 concrete verb and resource ("Writes down a message being prepared") and immediately frames the lifecycle (start one with "from", rewrite one by its id). It also distinguishes itself from send_email, so an agent can place it among 65 siblings 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?

Gives explicit when-to-use branches (pass "from" to create, pass draft_id to update) and an explicit when-not: "Saving sends nothing: send_email is what sends." The alternative tool is named with the condition that selects it.

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

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

No annotations exist, so the description carries the burden and does add real behavioral context: results are relevance-ranked ('best answer first'), and omitting folder searches the whole box. It does not address result shape, cost, or whether matching is case/accent-insensitive, but the absence of anything alarming plus the explicit ranking disclosure is solid for a read-only search.

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

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

Three tight sentences that front-load the capability, then the prerequisite, then the usage heuristic. Minor redundancy: 'call list_sender_addresses to find the box' repeats what the box parameter description already says verbatim.

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?

No output schema and no annotations, yet the description covers scope, ranking, and where to get the required box value, which is enough to call it correctly. It stops short of describing what a returned thread looks like or how to page past the limit.

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

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

Schema coverage is 100% and already documents q syntax, box format, limit range, and folder values. The description adds only a loose gloss of what q matches (subject, text, people, filenames), which is marginal value over the schema. 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?

States a specific verb and resource (finds threads of one mailbox) plus the searchable fields (subject, text, participants, attachment filenames) and the ranking behavior ('best answer first'). This is clearly a relevance search, distinguishable from enumeration siblings like list_conversations or retrieval via get_conversation.

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 both a prerequisite (call list_sender_addresses to obtain the box) and a clear use-case heuristic ('when you know a word of it and not where it is'). It does not explicitly name the alternative for the opposite case (enumerating a mailbox with list_conversations), so it stops short of full when/when-not coverage.

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

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

With no annotations, the description carries the full burden and does disclose real behavior: text is sent verbatim, scheduling holds delivery until send_at, and the thread created is where replies land. It stops short of stating whether a send is irreversible, what happens on failure, or what the tool returns, which matters for an outbound mutation.

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

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

Three sentences, front-loaded with purpose and the thread side effect, then the approval gate, then the scheduling variant. No filler and nothing important buried.

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 send tool with no output schema, the description explains the key consequence (a thread is opened for the reply) and the scheduling path. It does not cover what the call returns or auth/permission requirements on the from address, which is the one remaining gap for an agent invoking it correctly.

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

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

Schema coverage is 100%, so all nine parameters are already documented in detail, including send_at's format and offset rule and the attachment upload-vs-inline choice. The description adds only the cross-tool pointer that scheduled sends are visible via list_scheduled_sends, which is a marginal gain over the schema. 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?

States a specific verb and resource ('writes and sends an email') plus a non-obvious side effect ('opens the thread their answer will land in'). This distinguishes it from save_compose_draft, reply_to_conversation, and forward_conversation without needing 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?

Gives a clear selection rule: 'the text goes out as given, so this is the tool for a message a person has read and approved', which implicitly routes unreviewed text elsewhere. It also names list_scheduled_sends as the follow-up for the send_at path, but never explicitly names reply_to_conversation as the alternative for answering an existing thread, leaving a notable sibling boundary to inference.

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

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

With no annotations, the description carries the full burden and does a decent job: it discloses mailbox-wide blast radius ('on a box held by several people it moves the thread for all of them'), the reversal behavior ('comes back to the Inbox when a new message arrives'), and a rejection case for queues. It omits permissions needed and what the call returns, which keeps it below 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?

Four sentences with real content, but the lead sentence is long and indirect ('Says whether a thread of a mailbox leaves the Inbox for the Archive as soon as the box answers it'), burying the action behind a definition of the setting. Front-loading the operation would earn a higher 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?

For a two-parameter boolean toggle with no output schema and no annotations, the description covers the semantics, the blast radius, the reversal condition, and an inapplicable case. Only permissions and return behavior are unaddressed, which is a minor gap at this complexity.

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 both parameters are documented in-schema, including that address comes from list_sender_addresses. The description adds conceptual context about what the boolean governs but no syntax or format detail beyond the schema, so 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 resource is identifiable as the mailbox-level 'archive on reply' setting, but the opening phrase 'Says whether...' frames it like a query rather than a mutation, and the word 'set' only appears in the tool name. An agent must infer that this writes a boolean setting rather than reading one.

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

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

The description gives concrete scope conditions: it applies to shared boxes and moves the thread for every holder, while 'A helpdesk queue refuses it, its threads being worked by status' is an explicit when-not-to-use rule. It does not, however, point to any sibling settings tool (e.g. set_auto_draft) as an alternative.

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

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

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses what happens when the setting is off and suggests a cost-control implication, but it omits permissions, scope (user/workspace), immediacy of effect, and reversibility of the setting.

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

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

The description is two sentences and appropriately sized for a simple boolean setting. The second sentence adds useful context about manual drafting and cost, though the first sentence could be more front-loaded and direct.

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

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

For a simple one-parameter setting with full schema coverage and no output schema, the description covers the basic effect and off-state behavior. It remains incomplete regarding setting scope, permissions, and whether changes apply immediately, which matters for a mutation tool with no annotations.

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

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

There is one required boolean parameter and schema description coverage is 100%, so the schema already defines true/false behavior clearly. The description adds context about the off state and model spend but does not add syntax or operational 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 conveys that the tool controls whether Iris automatically drafts replies to incoming messages, but the phrasing 'Says whether' is imprecise for a setter and could momentarily read as a getter. It does not explicitly name sibling tools or contrast with manual drafting tools such as save_compose_draft.

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

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

The description implies usage by explaining that turning it off means drafts are written only when requested from the inbox, and hints at model-spend control. However, it does not state when an agent should call this tool versus leaving settings alone or using related drafting tools.

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