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

With no annotations supplied, the description carries the full behavioral disclosure burden. It does add useful context by stating that the password is not exposed and that the tool reports IMAP capabilities and the detected Sent folder, implying a read-only operation. However, it does not disclose return formatting, potential errors, or any other behavioral caveats.

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

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

The description is a single, compact sentence that front-loads the main purpose and lists the three key information categories. Every word contributes value, with no redundancy or filler.

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

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

For a parameterless informational tool with no output schema, the description is reasonably complete: it names the three outputs the agent can expect. It could be richer by describing the return format more precisely, but the core information needed to select and invoke the tool is present.

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

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

The tool has zero parameters and the schema is empty, so the baseline is 4. The description adds no parameter-specific meaning, which is acceptable because there are no parameters to document.

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

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

The description clearly identifies the tool's purpose: it shows the active account configuration, IMAP server capabilities, and the detected Sent folder. The verb 'Mostra' names a specific action on a specific resource, though it does not explicitly distinguish the tool from its 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?

There is no guidance on when to use this tool versus alternatives like list_folders or read_email. No prerequisites, exclusions, or typical call context are provided, so an agent must infer that this is the general account-info read.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. It adds one meaningful behavior detail—that subfolder paths use the server delimiter—but does not disclose behavior for duplicate folder names, permissions, or whether intermediate folders are created automatically.

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

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

The description is one concise sentence with no filler. The primary verb and resource appear first, followed immediately by the most important parameter 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 tool with no output schema, the description is largely complete: it tells the agent what to pass and how to express subfolders. Minor edge cases like existing folders or permission failures are not mentioned, but they are not essential for a correct basic 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?

With 0% schema description coverage, the description fully compensates by explaining that the single 'name' parameter should include the folder path and that subfolders are separated by the server delimiter, with concrete examples like 'INBOX/Clientes'.

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

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

The description clearly states a specific action and resource: "Cria uma pasta" (creates a folder). It does not explicitly distinguish itself from siblings, but sibling names like delete_folder, rename_folder, and list_folders are sufficiently distinct to avoid confusion.

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 useful context about using the server delimiter for subfolders, but it does not state when to use this tool versus alternatives or when not to use it. The usage guidance is implied rather than 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 provided, the description carries the burden and it discloses key behavior: emails are marked /Deleted)Skip and permanent removal happens only if expunge=True. It also implies mutating/possibly destructive behavior. It does not mention permissions, undo, or effects on shared mailboxes, but the core destructive behavior is transparent.

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, efficiently front-loaded with the core action and the key destructive nuance, followed by the relevant alternative. There is no filler or repetition of schema fields.

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

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

The description covers purpose, mechanism, and alternative routing, but lacks detail on UID format, folder naming expectations, and return/error behavior. Since there is no output schema and no annotations, those gaps remain unresolved, though the core deletion semantics are clear.

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

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

Schema description coverage is 0%, yet the description only clarifies expunge. The uids and folder parameters, which are required, receive no semantic explanation. This leaves an agent to infer what format uids should take and how folder names are resolved.

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-resource pair ('deletes emails') and gives a precise mechanism: marks /Deleted and optionally expunges permanently when expunge=True. It also explicitly differentiates itself from move_email, so an agent can distinguish it from the closest sibling without guessing.

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 routing guidance: if the user wants 'move to trash', use move_email instead. It does not explicitly state edge cases about when deletion is appropriate, but the semantic contrast is strong enough for typical agent 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. It discloses that the action is irreversible ('Irreversível') and that it deletes all messages in the folder, which is critical behavioral information. However, it does not specify whether subfolders are affected or any permission requirements.

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

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

The description is concise at two sentences, with the core action stated first and the warning second. It avoids unnecessary elaboration and is well-structured for quick parsing.

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 tool with one parameter and no output schema, the description covers the essential behavior and warns about irreversibility. It lacks details on edge cases or error conditions, but given the tool's simplicity, it is reasonably complete. However, it could benefit from clarifying the name parameter's expected format.

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 defines a single 'name' string parameter, but the description does not clarify its meaning (e.g., whether it expects a folder name or path). With 0% schema coverage, the description fails to add any semantic value beyond the schema's field name.

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

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

The description clearly states the tool removes a folder and all messages in it, using the specific verb 'Remove' and resource 'pasta'. It distinguishes from delete_email by specifying the folder context, leaving no ambiguity about what is deleted.

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

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

The description provides no guidance on when to use this tool versus alternatives like rename_folder or delete_email. It does not mention any conditions or exclusions, leaving the agent to infer usage from the name alone.

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 disclose the main side effect ('Salva anexos ... em disco'), the conditional index behavior, and the return value ('caminhos gravados'). However, it does not mention behavior on invalid indices, missing attachments, destination-directory handling, or potential overwriting.

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 deliver the tool's purpose, special-case behavior, and return value without unnecessary prose. Every sentence adds useful information and the key behavior is front-loaded.

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

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

The description is adequate at a high level but incomplete for a tool with four parameters and no annotations. It fails to specify valid folder/uid values, dest_dir semantics, failure behavior, or prerequisites, so an agent may not be able to invoke it correctly without external context.

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

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

Schema description coverage is 0%, so the description must compensate for undocumented parameters. It explains the meaning of index (-1 versus a specific index per read_email), but folder, uid, and dest_dir are left to inference from their names, and the dest_dir default is not described.

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 saves email attachments to disk, with a clear distinction from body-reading or message-management siblings. The phrase 'index=-1 salva todos' adds scope and identifies the special case, making it easy to tell from read_email or get_raw_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?

No explicit guidance is given for when to use download_attachment versus alternatives such as read_email or get_raw_email. The only hint is 'índice conforme read_email', which clarifies index alignment but not selection context 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?

No annotations are provided, so the description carries the full burden. It discloses that the body is text and attachments are original, and implies a write/mutation operation, but doesn't state whether the original email is modified, whether sent copies are saved (though save_to_sent param exists), or any side effects. The description adds some context but leaves significant behavioral gaps.

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

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

A single, concise sentence in Portuguese that front-loads the core action and key behavior. It's efficient, though it could add routing guidance without becoming bloated.

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, no output schema, and 7 parameters at 0% schema coverage, the description is too thin. It doesn't explain how the email is identified (folder/uid), how recipients are formatted, or what happens after forwarding. An agent would need to infer too much.

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

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

Schema description coverage is 0%, so the description must compensate. It explains that body is text and attachments are original, which maps to body and include_attachments, but it doesn't explain folder/uid identification, to/cc format, or save_to_sent behavior. With 7 parameters and zero schema descriptions, this is a substantial gap.

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

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

The description states a specific verb ('Encaminha' = forwards) and resource (an email with text body + original attachments) to new recipients. It clearly distinguishes from siblings like send_email and reply_email, though it doesn't explicitly name them.

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

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

The description implies usage context (forwarding an existing email) but provides no explicit guidance on when to use this tool versus send_email or reply_email. The sibling list shows these alternatives exist, but the description doesn't route the agent to them.

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

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

No annotations are provided, so the description carries full responsibility. It mentions returning raw source but does not disclose side effects (e.g., read status changes), performance characteristics, or limits despite a max_chars parameter existing. Serious behavioral gaps remain undocumented.

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 brief and front-loaded: the first sentence describes the core behavior immediately, and the second adds a diagnostic use case. No filler words; though under-specification is an issue, the structure itself is efficient.

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

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

Given the tool's complexity (3 params, no annotations) and an output schema, the description lacks essential missives: it does not cover when to use it, what max_chars controls, side effects, or safety profile. The output schema exists but distinguishes output type; critical usage context 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?

With schema description coverage at 0% and 3 parameters, the description added no parameter meaning. It does not explain folder/uid semantics or the max_chars truncation limit, forcing agents to guess.

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

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

The description clearly states a specific verb ('Retorna') and resource ('fonte RFC822 completa da mensagem'), specifying it includes raw headers and MIME. It distinguishes from a regular read by emphasizing the raw format, though it does not explicitly name read_email as an alternative.

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

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

The phrase 'Útil para diagnóstico' implies a use case but is vague; it does not state when not to use it or contrast with siblings like read_email or search_emails. There is no explicit exclusion or alternative mention.

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 disclosure burden. It correctly indicates the read-only nature of listing, adds that with_counts=true includes total and unread counts, and warns that this mode is slower. No destructive or side-effect warnings are needed for a listing operation.

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

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

The description is short, front-loaded with the primary purpose, and places the optional behavior and performance caveat in the second sentence. It is easy to parse and actionable.

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

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

The description covers the purposechen and the optional parameter with a performance note. Since there is an output schema availabletons and no required parameters, missing details are minimal. Could slightly improve by naming when to omit with_counts, but the default false handles that.

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

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

Schema coverage is 0%, but the description fully explains the only parameter: with_counts=True includes total and unread counts Writ and that it is slower. This directly adds meaning beyond the bare schema type/name. No other parameters exist.

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

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

The description clearly states a specific action ('Lists all folders') and a clear scope ('of the account'). It is easily distinguishable from siblings like create_folder, delete_folder, and rename_folder because it names the listing operation and the resource (mailboxes/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?

The intended use is clear: list all folders in the account. It also gives guidance on when to pass with_counts=true (when counts are needed) and warns it is slower. However, it does not explicitly contrast with alternatives, though the sibling set makes the distinction trivial.

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 full behavioral burden, and it does disclose a critical trait: it uses MOVE when the server supports it, otherwise falls back to COPY + delete + EXPUNGE. This tells the agent the operation can be destructive and server-dependent. However, it stops short of warning about partial-failure scenarios or the permanence of EXPUNGE.

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 sentence that front-loads the core purpose and then adds the key fallback behavior. Every phrase earns its place with no filler, while still covering both what the tool does and its most important behavioral nuance.

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

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

For a tool with no annotations, no output schema, and 0% parameter coverage, the description leaves significant gaps: uids is undefined, return values are unaddressed, and the irreversible EXPUNGE consequence is only implied, not stated. The fallback disclosure is strong, but it cannot compensate for these missing pieces.

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

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

Schema coverage is 0%, and the description adds almost no parameter meaning. 'Para outra pasta' hints that destination is the target folder, but uids (an array of integers) is entirely unexplained – an agent would not know these are IMAP message identifiers tied to the source folder, and folder is never explicitly stated as the source.

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 ('Move e-mails para outra pasta' – move emails to another folder) with a clear verb, resource, and target. It is not a tautology and the action is distinct from siblings like delete_email or set_flags, though it never names those alternatives explicitly.

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

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

There is no guidance on when to use this tool versus alternatives, no prerequisites (e.g., source and destination folders must exist), and no exclusions or conditions. The MOVE-versus-COPY fallback detail is behavioral implementation, not usage direction.

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 does disclose default body format and max_chars behavior, but it omits the significant side effect that mark_as_read defaults to true, meaning a 'read' operation mutates email state. This hidden mutating behavior is central and undocumented.

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 tight, front-loaded sentences with no filler. The main purpose is stated first, then a routing pointer, then a parameter-default clarification. Every sentence 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?

The description covers the core inputs (UID), the main output components (headers, body, attachment list), and the most nuanced default (max_chars). With no output schema and no annotations, it is reasonably complete for a read tool, but the missing mark_as_read side effect and unstated folder semantics leave a meaningful 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 0%, so the description must add parameter meaning. It explains max_chars=0 behavior and the text-vs-HTML body selection tied to prefer_html. However, it does not clarify the semantics of folder or mark_as_read, leaving two important parameters underdocumented.

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

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

The description clearly states the tool reads a complete email by UID and enumerates the returned content: headers, body (text or HTML), and attachment list. It names download_attachment as the related tool for saving attachments, but it does not explicitly distinguish itself from the sibling get_raw_email, 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 description provides a clear usage context: use this tool to read a full email by UID, and use download_attachment when the goal is to save attachments. There is no explicit exclusion of alternatives like get_raw_email or search_emails, so it is not fully exhaustive, but the guidance present is concrete and actionable.

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

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

No annotations are provided, so the description must bear the full burden of behavioral disclosure. It only states the action 'renames' without explaining side effects such as possible loss of associated data, permission requirements, error conditions, or reversibility. For a mutation operation, this leaves substantial hidden behavior unexplained.

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

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

The description is a single, short sentence with no filler, which is structurally efficient and has the core action front-loaded. However, its brevity is not a virtue when it omits crucial contextual information; it is concise but at the expense of necessary detail, so it earns a high score for conciseness but not the top.

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

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

For a tool with only two parameters and no output schema, one might argue the core action is self-evident. Yet with no annotations and a description that is merely a translation of its name, the agent is left with no information about ownership of the folder, whether the operation is empathetic, or what the return behavior is. The terse description, in particular, does not fully cover what the agent needs to know.

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

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

With schema description coverage at 0%, the parameter descriptions are completely absent from the schema and the tool description does not compensate. There is no elaboration on what "name" and "new_name" represent, how they should be formatted, or what constraints apply. The description literally adds zero information about the parameters.

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

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

The description "Renomeia uma pasta" translates to "Renames a folder", which is essentially the same as the tool name itself. It restates the title without providing any additional context or distinguishing details about what this operation entails, and it is written in Portuguese while sibling tool names are in English, which adds ambiguity for an agent operating in English.

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

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

There is no guidance on when to use this tool versus related siblings like create_folder, delete_folder, or list_folders. The description does not mention any conditions, prerequisites, or alternatives, leaving the agent to infer usage purely from the name.

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

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

With no annotations, the description carries the full burden of disclosing side effects. It usefully mentions that threading headers are preserved and that the email is marked as replied, but it does not disclose other important behaviors such as sending, saving to Sent, quoting behavior, or attachment 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 a single well-structured sentence that front-loads the primary action and then adds the two key behavioral details: threading preservation and marking as replied. No words are 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?

Given the tool has 8 parameters, no annotations, and no output schema, the description is too sparse to fully guide correct invocation. It omits how folder and uid identify the message, what reply_all and quote_original do, and what the agent should expect after the reply is sent.

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

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

Schema description coverage is 0%, and the description provides no explanation of uid, folder, body, html, reply_all, attachments, save_to_sent, or quote_original. An agent gets no semantic help beyond parameter names and defaults, which is insufficient for 8 parameters.

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

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

The description clearly states a specific verb ('Responde') and resource ('um e-mail existente'), and distinguishes the tool from send_email and forward_email by emphasizing threading and marking the email as replied. The use of 'existente' makes the scope unambiguous.

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

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

The phrase 'e-mail existente' communicates that this tool is for replying to an already received message rather than composing a new one or forwarding. It does not explicitly name alternatives or state when not to use it, but the context is reasonably 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?

No annotations are provided, so the description carries the full burden. It discloses key behaviors: returns most recent first, includes specific fields, supports date range with YYYY-MM-DD format, and describes the effect of raw_criteria (ignores other filters). It also clarifies that substring filters are case-insensitive. This is transparent enough for an agent to understand what it does and how it behaves.

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 concise and well-structured. It has three clear sentences: first states purpose and return fields, second covers date format and raw_criteria override, third explains filter semantics. No fluff, and the most important information (what it does, what it returns) is front-loaded.

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

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

Given the tool's complexity (12 parameters, no required params, no output schema), the description covers key aspects: search scope, return fields, behavior modifiers (raw_criteria, date range), and filter types. It doesn't detail pagination or how limit works, but that's partially in the schema. The output schema is absent, so return details are partially covered. It's adequate for selecting and invoking the tool, though a bit more might be expected for such a parameter-rich 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?

With 0% schema description coverage, the description must compensate for understanding parameters. It explains the format for since/before, the function of raw_criteria (overrides other filters), and the nature of sender/to/subject/text as substring filters. It omits details on limit (default 20) and larger_than_kb, but the schema provides defaults. The description adds value beyond the schema for date and raw_criteria parameters.

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

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

The description clearly states the tool's purpose: searching emails in a folder. It mentions the resource (emails in a folder) and the action (search), along with key return fields (UID, sender, subject, date, flags). It distinguishes itself from siblings like read_email and list_folders by focusing on search behavior.

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

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

The description provides clear context on how to use the tool: returns most recent first, supports date range, substring filters, and raw_criteria for advanced IMAP search. It doesn't explicitly state when not to use it or list alternative tools, but the sibling list is available. However, it gives enough guidance for typical search queries.

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 carries the behavioral disclosure burden and does it well: it discloses SMTP transport, recipient separators, html=True semantics, attachment path expectations, and that save_to_sent=True writes a copy to the Sent folder via IMAP. It adds material behavioral context beyond the schema.

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

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

The description is three short sentences with no filler. It front-loads the core action, then adds parameter clarifications, and ends with the side-effect behavior. Every sentence adds 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?

For a nine-parameter tool with no annotations and no output schema, the description covers the key behavioral and parameter nuances well. Minor gaps remain around error behavior, sending limits, or return values, but the essential context for calling this tool 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 0%, so the description must compensate. It explains the meaning of several parameters: recipient separators for to/cc/bcc, html=True treating body as HTML, attachments as local paths, and save_to_sent affecting Sent-folder copying. It does not detail reply_to, but the main ambiguous parameters are clarified.

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

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

The description clearly states that the tool sends an email via SMTP, using a specific verb and resource ('Envia um e-mail via SMTP'). It does not explicitly differentiate from siblings like reply_email or forward_email, but the message that it sends a new email with recipients, subject, and body is unmistakable.

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

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

There is no guidance on when to use this tool versus alternatives such as reply_email or forward_email. The description implies it is for sending new emails, but it does not state exclusions or mention when another sibling would be more appropriate.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It clearly explains the effect of each boolean value and that multiple UIDs can be processed, but it omits any mention of side effects, error conditions, response format, or reversibility. Additionally, it does not describe how the folder parameter influences behavior beyond being required.

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

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

The description is two concise sentences with no redundant words. The actions and parameters are front-loaded, and the critical usage pattern (True/False/omit) is stated immediately. Every sentence contributes to understanding.

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?

While the description adequately covers the flag semantics and the ability to handle multiple UIDs, it is incomplete for an agent that must call the tool correctly. It does not mention failure modes, the meaning of 'folder', or what response to expect. Given there is no output schema and no annotations, a more comprehensive description that covers these aspects would be expected.

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

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

Schema coverage is 0%, so the description must compensate. It explains the semantic meaning of the three boolean flags (True/False/omit) and explicitly states the tool operates on multiple UIDs. This adds value beyond the bare schema. However, it does not elaborate on the 'folder' parameter, which is a required string but its role in selecting the mailbox is left implicit.

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 precise action: marking/unmarking flags on UIDs, and explicitly enumerates the three flags (seen, flagged, answered). This clearly differentiates it from sibling tools that handle reading, moving, or deleting messages, leaving no ambiguity about 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?

The description explains how to use the tool (True to add, False to remove, omit to not change) but provides no explicit guidance on when to choose this tool over alternatives, such as read_email which may implicitly mark messages as seen. The context implies it's for flag manipulation, but there is no explicit exclusion or alternative mention.

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