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 one real behavioral trait: secrets (passwords/tokens) are never returned. That is genuinely useful. It does not state whether the call is read-only, whether it requires authentication, whether it is expensive/side-effecting, or what 'readiness' is assessed against.

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

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

Two short sentences, front-loaded with the purpose and followed by the safety guarantee. Nothing is wasted, though 'non-secret configuration readiness' is compressed to the point of ambiguity.

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

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

An output schema exists, so return values need not be explained, and zero parameters keep the schema side trivial. However, with no annotations and several sibling status/diagnostic tools, the description should clarify what readiness means and how this differs from capabilities or test_connection; that gap leaves it only minimally complete.

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

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

The tool takes zero parameters, so the baseline of 4 applies. The description correctly adds nothing about parameters because there are none to describe.

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 verb ('Return') and a resource ('configuration readiness'), so the purpose is roughly discernible, but 'non-secret configuration readiness' is vague jargon. It does not distinguish itself from overlapping siblings such as capabilities, test_connection, or folder_status, leaving the agent unsure which status check to pick.

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

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

No when-to-use guidance is given at all. There is no mention of when this should be called versus test_connection or capabilities, both of which plausibly answer similar 'is this account usable?' questions.

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

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

No annotations are provided, so the description carries the full burden. It does disclose one genuinely non-obvious behavior — the destination resolves to a configured or server-advertised archive folder — but says nothing about permissions, what happens if no archive folder exists, or whether the move 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?

A single front-loaded sentence with no filler, and the destination is stated up front. It is efficient, though it is terse enough that the brevity contributes to the gaps elsewhere.

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

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

For a mutation tool with no annotations and two entirely undocumented parameters, this is under-specified. An output schema exists so return values need not be described, but the failure modes, permission requirements, and folder-parameter semantics are all 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 description coverage is 0%, so the description must compensate and it does not. It never explains the 'uid' selector, and because it frames the target as a fixed archive folder it leaves the role of the 'folder' parameter (default INBOX, presumably the source folder) ambiguous.

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 ('Move a message') plus the destination ('archive folder'), which is concrete enough to act on. It implicitly separates itself from the generic sibling move_message by fixing the destination, but never names that sibling or the distinction explicitly.

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

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

Usage is only implied: an agent can infer this is for parking a message in the archive rather than deleting (delete_message) or relocating to an arbitrary folder (move_message). No explicit when-to-use, when-not-to-use, or alternative is 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 behavioral burden, but for a zero-parameter read-only introspection call the risk surface is minimal. It usefully discloses that the output covers both supported features and webmail/server-only limitations, yet says nothing about freshness, caching, or whether it reflects the live server configuration.

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 or redundancy. Every word contributes to defining scope.

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

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

An output schema exists, so return values need not be explained, and the low complexity of a no-argument introspection tool keeps requirements modest. The only real gap is that the agent is not told where in a workflow this call belongs.

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 disambiguate. Baseline 4 applies; no parameter detail is needed or missing.

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 subject: it reports supported features plus known server/webmail-only limitations. That is distinguishable from sibling meta tools like account_status or test_connection, though the description does not explicitly contrast itself with them.

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

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

There is no guidance on when to call this versus alternatives such as account_status or test_connection, nor any indication that it should be consulted before attempting operations that may be unsupported. The agent must infer the usage context entirely.

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

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

No annotations are provided, so the description carries the full behavioral burden. It says a folder is created but omits critical traits: what happens if the folder already exists, whether creation is idempotent, required permissions, and how nested names or delimiters are handled.

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

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

The one-sentence description is front-loaded and free of filler, but it is so terse that it under-specifies a mutation operation. It is structurally clean yet earns only minimal credit for substance.

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

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

An output schema exists, so return values need not be explained. However, for a mutation tool with no annotations and an undocumented parameter, the description leaves error behavior, permissions, and folder-name semantics entirely unaddressed.

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 required parameter 'name' has 0% schema description coverage, and the description never mentions it. It does not clarify whether the name is a display name, a path, or a delimiter-separated hierarchy, so it adds no semantic value beyond the bare schema property.

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 ('Create an IMAP folder'), which cleanly separates it from rename_folder, delete_folder, and list_folders. It stops short of explicit sibling routing, so it is clear but not maximally 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?

There is no when-to-use guidance, no prerequisites, and no mention of alternatives such as rename_folder or list_folders. Usage is only implied by the verb.

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 usefully discloses the destructive nature and the confirm guard, and the word 'local' implies remote/server contacts are untouched. It does not state irreversibility, error behavior when confirm is false, or 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?

Two short sentences, zero filler, with the action stated first and the hard precondition immediately after. Nothing to trim.

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

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

An output schema exists, so return values need not be explained. The description covers scope ('local') and the safety precondition for a simple two-parameter mutation; only reversibility/remote-contact side effects are left unstated.

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

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

Schema description coverage is 0%, so the description must compensate. It documents the confirm parameter's required value, which is the non-obvious one; contact_id is self-explanatory and required. Partial but meaningful compensation.

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 ('Delete a local contact'), which is enough to separate it from delete_message and delete_folder in the sibling list. It does not explicitly name the sibling it competes with (e.g. upsert_contact), so it stops short of full differentiation.

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

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

'Requires confirm=true' gives a real precondition for invocation, which is more than implied usage. However, it offers no when-to-use/when-not guidance and names no alternative for editing rather than removing a contact.

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

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

No annotations are provided, so the description carries the full burden. It does disclose the confirm gate, which is genuinely useful safety context for a destructive call, but omits whether deletion is permanent, what happens to contained messages, and whether protected folders can be targeted.

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, with the destructive action stated first and the precondition second. Nothing to trim.

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

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

An output schema exists so return values need no explanation. However, for an irreversible mutation with no annotations, the description should at least state irreversibility or the fate of contained messages; the confirm gate alone is a minimum-viable level of completeness.

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 there are 2 parameters. The description explains the confirm parameter's required value, but says nothing about the required name parameter (e.g., whether it takes a path, delimiter, or folder ID), leaving half the surface undocumented.

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 ("Delete an IMAP folder") that is immediately distinguishable from siblings like create_folder, rename_folder, and folder_status. It stops short of naming alternatives or scope limits, so it is clear but not maximally 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?

"Requires confirm=true" is a real precondition and implicitly signals this is a guarded destructive action, but there is no explicit when-to-use/when-not guidance, no mention of system folders like INBOX, and no alternative suggested for non-destructive cleanup.

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 the safe default (move to Trash) and that permanent deletion is gated behind both permanent=true and confirm=true, a genuine safety-relevant behavior. It omits auth/permission requirements and confirmation of irreversibility.

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 terse sentences, zero waste, with the default behavior front-loaded ahead of the opt-in destructive path. Exactly the right size for the information conveyed.

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

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

An output schema exists so return values need not be described. However, for a destructive tool with no annotations, the description should say more about irreversibility, the folder parameter's role, and permission requirements; it covers the mode switch but not the surrounding 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% across 4 parameters, so the description must compensate. It meaningfully explains the interaction between permanent and confirm (both required for hard delete), but leaves uid and folder undocumented, covering only half 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 name plus description make clear this deletes a specific message, and the description adds the crucial distinction between Trash and permanent removal. It does not explicitly differentiate from siblings like archive_message, move_message, or delete_folder, but the verb+resource is unambiguous.

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

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

The description explains the two deletion modes but gives no guidance on when to delete versus archive_message or move_message, and no prerequisites or warnings about choosing permanent deletion. Usage context is left entirely to inference.

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

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 only that something is written to a local directory; it does not mention permissions/auth needs, what happens when the index is out of range, whether existing files are overwritten, or size/rate limits.

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

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

A single front-loaded sentence with no filler. It is efficient, though the extreme terseness leaves the definition under-specified rather than genuinely well-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?

An output schema exists, so return values need not be explained. However, for a tool that writes to disk with zero annotations and 0% parameter coverage, the description is too sparse: no auth/permission context, no failure behavior, and no parameter meaning are provided.

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

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

Schema description coverage is 0%, so the description must compensate for four undocumented parameters. It only gestures at 'index' (attachment_index) and 'local directory' (output_dir); uid, folder, and the INBOX default are never explained, and no format or constraint guidance is added.

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 (download) and resource (attachment) with scoping detail ('by index to a local directory'). It clearly communicates the operation, though it does not differentiate itself from any sibling tool the way sibling-routing context would require.

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

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

There is no when-to-use guidance, no prerequisites, and no alternatives named. The tool's role in a workflow (e.g. after list_messages or get_message to fetch attachments) is left entirely to inference.

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

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 implies a read but says nothing about required permissions, behavior for a nonexistent folder, or whether counts include subfolders. Only the returned data shape is hinted at, and an output schema already covers that.

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

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

A single front-loaded sentence with the verb, resource, and returned metrics in one pass; every word earns its place 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?

An output schema exists, so return values need no explanation, and the tool is a simple read with one optional parameter. However, the undocumented default and folder-identifier format leave a real gap for correct invocation, and no annotations backstop the safety profile.

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 only says 'one folder', omitting the parameter's default ('INBOX') and the accepted identifier format (folder name vs. ID/path). It adds little beyond the schema's bare 'folder' property.

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 ('Get') and resource ('folder'), and specifies exactly what is returned (total and unread counts). It implicitly distinguishes itself from account_status (account-wide) and list_folders (enumerating folders), though it never names those siblings explicitly.

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

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

No when-to-use guidance and no alternatives named. An agent must infer from the name that this is for per-folder counts rather than account-wide counts (account_status) or folder enumeration (list_folders); nothing in the text routes the choice.

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

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

No annotations are provided, so the description must carry the full behavioral burden. It discloses only that dry_run defaults to true, which is already visible in the schema default, and says nothing about whether forwarding actually delivers mail, whether the original is mutated, or what side effects occur.

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

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

Two short sentences with no padding, and the core action plus the safety-relevant default are front-loaded. It is efficiently sized for what it attempts, though the second sentence duplicates a schema default.

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 six undocumented parameters and no annotations, the description is far too thin. An output schema exists so return values need not be explained, but the gap on parameter meaning and mutation side effects is significant.

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% for 6 parameters, so the description must compensate and does not. It explains only dry_run (a schema default) and says nothing about uid, to, folder, body_prefix, or include_original_attachments.

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 ('Forward an existing message'), which is immediately actionable. However, it does not distinguish this tool from adjacent siblings like reply_message or send_message, leaving the agent to infer 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?

There is no guidance on when to forward versus reply or send a new message, nor any mention of prerequisites such as the message needing to exist or the caller needing send permissions. Usage is only implied by the tool name.

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

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

With no annotations, the description carries the full burden, and it does disclose one genuinely useful behavioral trait: the message is not marked read. However, it says nothing about behavior on a missing/invalid uid, folder resolution, or how max_chars truncation works, leaving real gaps for a read tool.

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

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

A single tight sentence that front-loads the action and folds in the return content and the key non-destructive guarantee with zero waste.

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

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

Although an output schema exists, the tool takes four undocumented parameters with 0% schema coverage and has no annotations, so the description should compensate for folder defaults, truncation via max_chars, and include_html behavior. It does not, so an agent lacks what it needs for anything beyond the default call.

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

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

Schema description coverage is 0% and the description never references any of the four parameters (uid, folder, max_chars, include_html). 'headers/body/attachments' weakly hints at content selection but provides no meaning about defaults or how include_html/max_chars shape the result.

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 ('Read') and resource ('one message'), and the list of returned content (headers/body/attachments) pins down what the operation yields. The singular 'one message' implicitly separates it from list_messages/search_messages, though no sibling is named explicitly.

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

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

There is no explicit when-to-use guidance or mention of alternatives such as search_messages or list_messages. Usage for a single-message read is only faintly implied by 'one message', so an agent gets almost 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?

No annotations are provided, so the description bears the full burden of behavioral disclosure. It never states whether this creates or merges contacts, how duplicates are handled, what permissions or account state are required, or that it mutates local contact data.

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

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

A single efficient sentence that front-loads the main action and the optional variant. Nothing is wasted, though it is arguably too terse for the gaps it leaves.

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

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

An output schema exists, so return values need not be described, but for a mutation tool with no annotations and three fully undocumented parameters the description is far too thin to let an agent call it correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It only maps loosely to include_recipients ('optionally recipients'); the 'limit' and 'folder' parameters, including their defaults, are never explained in prose.

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 (import) and resource (sender/recipient addresses into local contacts), so an agent knows exactly what the tool accomplishes. It does not explicitly contrast itself with siblings like upsert_contact or list_contacts, so it stops short of a 5.

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

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

There is no when-to-use or when-not-to-use guidance and no named alternative. The word 'recent' implies a source of correspondence, but the agent is left to infer when this is preferable to upsert_contact or list_contacts.

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 the important scope trait that results come from the local private store rather than the server, but it says nothing about result size, pagination, or ordering for what is presumably an enumeration tool.

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

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

A single sentence that front-loads the verb and resource and spends its only extra clause on the most important disambiguation (local vs. server-side). Nothing is wasted.

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

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

With zero parameters and an output schema present, the description need not explain return values. It supplies the key scope caveat, leaving only minor gaps around ordering/pagination behavior for a listing 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 zero parameters, so there is nothing for the description to disambiguate and the baseline of 4 applies. Schema coverage is 100% on an empty object, leaving no gap to compensate for.

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 ('List') and a specific resource ('MCP local private contact book'), and explicitly contrasts it with Tencent server-side contacts. It does not, however, distinguish itself from the sibling search_contacts, which an agent might reasonably confuse it with.

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 parenthetical exclusion ('not Tencent server-side contacts') tells the agent which data source this covers, which is genuine scope guidance. It stops short of saying when to use this versus search_contacts (e.g., full enumeration vs. query-based lookup), so usage is only implied.

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

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

No annotations exist, so the description carries the full burden; it does convey that results include special-use roles, which hints at the read-only listing behavior. However, it says nothing about whether folders are returned hierarchically, their ordering, or permission/auth requirements for the mailbox.

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

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

One front-loaded sentence naming the verb, resource, and notable result content with no wasted words.

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

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

An output schema exists, so return values need not be described, and the zero-parameter surface keeps the burden low. The only mild gap is that folder hierarchy and ordering are not mentioned, but that is plausibly covered by the 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?

Zero parameters, so there is nothing for the description to compensate for; the baseline for a param-less tool 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 (List) plus resource (IMAP folders) with a qualifier naming what the results include (special-use roles such as Drafts, Sent, Trash, Junk). An agent can distinguish it from most siblings, though no explicit contrast is drawn with the near-neighbor folder_status.

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

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

The description gives no when-to-use guidance, no preconditions, and no alternatives among the folder-related siblings (folder_status, create_folder, rename_folder, delete_folder). Usage is only inferable 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 behavioral burden. It usefully discloses that listing does not mark messages read, which is important non-obvious behavior, but it does not confirm read-only status, mutation risk, pagination, or permission requirements.

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

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

A single, front-loaded sentence with no wasted words. It efficiently conveys the core action and the most important side-effect constraint.

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 four undocumented parameters, no annotations, and no schema descriptions, the description is too thin. An output schema exists so return values need not be explained, but the parameter behavior and selection context remain largely unspecified.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions the folder concept and newest ordering, but does not explain limit, unread_only, starred_only, or how those filters interact with the default folder behavior.

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

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

States a specific verb (list), resource (messages), scope (newest in a folder), and a key side-effect behavior (without marking them read). It is clear enough to distinguish from get_message and search_messages, though it does not explicitly name alternatives.

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

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

Provides no explicit when-to-use guidance or alternatives. It implies listing newest messages, but does not say when to choose this over search_messages, list_folders, or other message-listing siblings.

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

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

No annotations are provided, so the description carries the full disclosure burden. It does convey useful behavioral context — the values come from environment configuration rather than user data, and 'explicitly allowed' frames it as an allowlist — which implies a read-only, non-mutating operation. However, it says nothing about permissions required, whether the list can be empty, or any rate/scope limits.

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

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

A single tight sentence with no filler, and the operative noun (sender addresses / allowlist) is front-loaded after the verb. It is appropriately sized for a zero-argument listing tool.

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

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

An output schema exists, so return-value shape need not be described. Still, for a tool whose central concept ('sender aliases' as distinct from the description's 'sender addresses') is slightly ambiguous, the description could have clarified the concept or its relationship to send_message. Adequate but with a visible 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?

The tool takes zero parameters, so there is no per-argument semantics to document; per the rubric, a parameterless tool defaults to a 4 baseline. Nothing in the description contradicts the empty 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 gives a clear verb ('List') plus resource ('sender addresses explicitly allowed by environment configuration'), which is specific enough to distinguish it from every sibling tool in the set — none of the others deal with allowed-sender configuration. It stops short of the 5 bar only because it does not explicitly contrast itself with any related sibling.

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

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

There is no when-to-use or when-not-to-use guidance and no mention of alternatives. An agent can infer this is a read of configured sender allowlist entries, but nothing tells it under what circumstances it should call this versus, say, list_contacts or capabilities.

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 of behavioral disclosure. It implies a mutation but does not state permissions required, reversibility, side effects, or what happens if the target folder does not 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 single sentence is concise and front-loaded, but it is under-specified for a three-parameter mutation tool. Brevity here reflects missing information rather than efficient communication.

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, 0% schema description coverage, and a mutation operation, the description is incomplete. Although an output schema exists, the description still fails to explain parameter meanings or behavioral expectations.

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 explain the three parameters. It vaguely references 'folders' but does not define uid, folder, or target_folder, nor does it mention the default 'INBOX' source folder.

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 ('Move') and resource ('message'), making the basic action clear. However, it does not differentiate this tool from siblings like archive_message or delete_message, which could also relocate or remove messages.

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

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

The description provides no guidance on when to use this tool versus alternatives. There is no mention of prerequisites, when-not-to-use conditions, or related tools such as archive_message or delete_message.

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, yet it only adds the "IMAP" protocol qualifier. It says nothing about permissions required, whether contained messages are preserved, behavior on missing/duplicate names, or error cases for what is clearly a mutating 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?

A single short sentence with zero filler, front-loaded with the action. It is efficient, though its brevity reflects under-specification rather than disciplined concision.

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

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

An output schema exists, so return values need not be described. However, for a mutating, unannotated, two-parameter tool with 0% schema coverage, the description leaves out permissions, failure modes, and parameter formats, which is not complete enough for an agent to invoke confidently.

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% for two required parameters. The description does not explain old_name/new_name semantics — e.g. path separators, case sensitivity, or whether the folder is identified hierarchically — so it fails to compensate for the schema gap. Titles ("Old Name"/"New Name") make the fields self-explanatory, which prevents a 1.

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 ("Rename an IMAP folder"), which is unambiguous and clearly distinct from siblings like create_folder and delete_folder by implication of the different operation. It does not explicitly name or contrast those siblings, 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 gives no when-to-use guidance, no preconditions (e.g. folder must exist), and no mention of alternatives. An agent can infer usage from the sibling set, but nothing in the text guides the choice.

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

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

With no annotations, the description carries the full burden, and it does disclose one important safety trait: the operation defaults to dry_run=true, so the first call is a preview rather than a real send. However, it omits whether the reply is actually transmitted, permission/authentication needs, and handling of attachments or threading, which matters for a 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?

Two compact sentences with the core action front-loaded and the safety default appended, so nothing is wasted. It is arguably too terse for a 6-parameter mutation tool, but as structure it is efficient.

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

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

An output schema exists, so return values need not be explained, but for a send-type tool with zero annotations and zero parameter documentation the description should cover permissions, side effects, and how the reply is addressed. Those gaps leave the agent unable to confidently invoke it in a real (non-dry-run) scenario.

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% across 6 parameters, and the description only touches reply_all and dry_run — both of which are already self-evident from their boolean names and the schema's own default values. Required parameters uid and body, plus folder and attachment_paths, get no explanation of expected format or intent.

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

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

The description names a specific verb and resource ('Reply/reply-all to an existing message'), which is more precise than a bare name and clarifies that it acts on an existing message rather than composing a new one. It does not explicitly contrast with siblings like forward_message or send_message, 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?

There is no when-to-use guidance, no mention of alternatives (forward_message, send_message), and no stated prerequisites such as the message needing a valid uid. The only actionable hint is the dry_run default, which is behavioral rather than a routing rule.

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 only that the draft is stored server-side and not sent; it says nothing about required auth, which folder the draft lands in, idempotency on repeated saves, or whether an existing draft is overwritten.

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 clean, front-loaded sentence with no waste, but for an 8-parameter mutation tool with no annotations the sizing is too terse to be 'appropriate' — the brevity is under-specification rather than economy.

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

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

An output schema exists so return values need no explanation, but the definition is still incomplete: no annotations, zero parameter documentation, and no statement of auth requirements or draft destination for a write operation.

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

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

Schema description coverage is 0% across 8 parameters, so the description must compensate and it does not — it never mentions to/cc/bcc, subject, body vs. html_body, from_address, or attachment_paths. An agent gets no guidance on field formats or on which of body/html_body takes precedence.

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 and resource ('Save a ... draft') and adds a scope qualifier ('server-side ... without sending it') that separates it from send_message/reply_message. It does not differentiate itself from update_draft, the closest sibling, which is the one gap.

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

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

'without sending it' implies the condition for choosing this over send_message, but the description never states when to use save_draft versus update_draft (new draft vs. existing draft) or any prerequisite. Usage is only weakly 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?

No annotations are provided, so the description carries the full behavioral burden, and it discloses almost nothing. It does not say what fields are matched (name, email, address), whether matching is substring/fuzzy/prefix, or whether results are capped or ranked. Read-only nature is only implied by '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?

A single efficient sentence with the resource front-loaded and no filler. It is concise, though partially because it omits necessary detail rather than because it is well-scoped.

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

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

An output schema exists, so return values need not be explained. But for a one-param search tool with no annotations and no sibling differentiation, the description leaves the matching semantics and its relationship to list_contacts entirely unaddressed.

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% for the single required 'query' parameter, and the description adds no meaning beyond the parameter name. It never states what the query is matched against or what format is expected, so the description fails to compensate for the coverage gap.

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

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

States a specific verb ('Search') and resource ('contact book'), so the agent knows what the tool does. However, it does not distinguish itself from the sibling list_contacts or explain what makes 'search' different from listing or browsing.

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

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

No when-to-use guidance, no conditions, and no mention of alternatives such as list_contacts for browsing the full book. The agent must infer that this tool is for finding contacts by a query string.

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 of behavioral disclosure, yet it says nothing about pagination, result ordering, authentication, or whether the search is exhaustive. Only the date-format note is given, and that is parameter syntax rather than 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?

Two short sentences with the scope constraint front-loaded and no wasted words. However, the sparseness reflects under-specification rather than disciplined conciseness, so it earns only a middling 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?

An output schema exists, so return values need not be explained. But for a 10-parameter, zero-coverage, annotation-free search tool, the description leaves nearly all filter semantics and all behavioral traits unstated, which is not enough 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 description coverage is 0% across 10 parameters, so the description must compensate, but it addresses only since/before (ISO format). text, sender, subject, recipient, limit, folder, unread_only, and starred_only are left entirely undocumented in both structured data and prose.

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

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

States a specific verb (Search) and resource, and adds a scope constraint ('one folder') that an agent can act on. It does not explicitly distinguish itself from the sibling list_messages, but the verb+scope makes the intent legible enough to select it.

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

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

There is no when-to-use guidance, no statement of when-not-to-use, and no mention of the obvious alternative list_messages. The 'one folder' phrase implies scoping but never explains the condition under which a search is preferable to a plain listing.

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 it does disclose the most safety-critical trait: dry_run defaults to true and sending requires user approval. Beyond that it says nothing about authentication requirements, how attachment_paths are resolved, or how html_body interacts with body, leaving notable gaps for a 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?

Two short sentences, zero filler, with the safety-critical default front-loaded. Nothing is wasted.

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

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

For a 9-parameter mutation tool with no annotations and 0% schema description coverage, the description covers only the dry_run workflow. An output schema exists so return values needn't be explained, but parameter intent and permission expectations remain undocumented.

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

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

Schema description coverage is 0% across 9 parameters, so the description must compensate and it does not. Only dry_run is addressed (and its default is already in the schema); to, cc, bcc, subject, body, html_body, from_address, and attachment_paths get no added meaning, not even format or precedence hints.

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?

"Compose/send mail" names the resource and an action, but the paired verbs blur whether this tool only sends or also composes, and nothing distinguishes it from siblings like reply_message, forward_message, or save_draft. An agent knows the domain but must infer 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?

It gives a real workflow rule — defaults to dry_run=true, and the actual send happens only after the user approves the preview — which is useful when-to-use context. However, it never states when to prefer this over save_draft, reply_message, or forward_message, so alternative selection is left to inference.

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

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

With no annotations, the description carries the full behavioral burden. It implies a mutation but never says whether the operation is idempotent, what null flag values do (leave unchanged? clear?), what permissions are needed, or whether the change is reversible. Only the surface effect is disclosed.

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

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

A single front-loaded sentence with zero filler; the core effect is stated before anything else.

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 4-parameter mutation tool with no annotations and 0% schema coverage, the description is too thin. Although an output schema exists (so return values needn't be explained), the missing uid/folder semantics and undefined null-flag behavior leave the agent unable to call it confidently.

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 all four parameters lack documentation in structured fields. The description obliquely conveys the meaning of read and starred via 'read/unread' and 'starred/unstarred', but says nothing about uid, the folder parameter, or — critically — that null (the default) means the flag is untouched.

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 (Set) and resource (message read/starred flags), and enumerates the two flag axes precisely enough to distinguish it from mutation siblings like move_message, archive_message, and delete_message. It does not explicitly name a sibling it differs from, 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?

There is no when-to-use guidance, no prerequisites (e.g. that the message must be identified by uid within a folder), and no mention of alternatives such as get_message for reading flag state. The agent gets a capability but no routing context.

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

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

With no annotations provided, the description carries the full burden and does disclose the key behavioral trait: it exercises authenticated IMAP and SMTP paths but explicitly does not read or send mail, so it is side-effect free. It does not address what happens on partial failure (IMAP ok, SMTP down), timeouts, or whether stored credentials are 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?

One sentence, front-loaded with the action and scope, with the side-effect guarantee trailing it. There is no filler, hedging, or restatement of the tool name.

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

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

For a no-argument diagnostic with an output schema that already describes return values, the description supplies purpose and safety profile adequately. A minor gap is that it does not say whether both protocols are tested together or how a partial result is reported.

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 and the schema is empty, so there are no parameter semantics to clarify; the baseline for a 0-param tool is 4. Nothing in the description contradicts or misrepresents 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 gives a specific verb+resource ("Test authenticated IMAP and SMTP connectivity") and adds a scope constraint, "without reading or sending mail," which separates it from mail-operation siblings like get_message and send_message. It does not explicitly name an alternative diagnostic sibling such as account_status or capabilities, so it falls short of the 5 benchmark.

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

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

Usage is only implied: an agent can infer this is the right tool when it wants to validate credentials/server reachability with no side effects. The description never states when to prefer this over account_status or capabilities, nor any preconditions, so guidance stays at the implied level.

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 does disclose a real behavioral trait: a confirmation flag is mandatory, hinting at a guarded destructive operation. However, it never states that the whole draft is overwritten (not a partial patch), what happens to omitted optional fields like attachments, or whether the replacement 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 operation and followed by the hard precondition. No filler and nothing 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 an 11-parameter, no-annotation, high-impact mutation tool, the description is far too thin. It omits replacement-vs-merge semantics, how the target draft is identified (uid + folder), and how optional fields behave, leaving an agent likely to misuse it.

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

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

Schema description coverage is 0% across 11 parameters, so the description must compensate, but it only references one parameter (confirm_replace). The meanings of uid, folder, to, cc, bcc, body, html_body, from_address, and attachment_paths are left entirely to bare titles.

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 ('Replace an existing draft'), which clearly contrasts with the sibling save_draft by signaling mutation of an existing object rather than creation. It does not name the sibling explicitly, but the operation 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?

It gives a precondition ('Requires confirm_replace=true') but no explicit when-to-use guidance or routing against alternatives like save_draft or send_message. Usage is only implied by the word 'existing'.

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 convey upsert semantics (match on email, then create or update), which is real value, but says nothing about permission requirements, whether omitted fields overwrite or preserve existing values, or what happens on conflicting data.

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 zero waste. It is efficient, though the extreme brevity for a 6-parameter mutation tool borders on under-specification rather than conciseness.

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

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

An output schema exists, so return values need not be explained, but a mutation tool with no annotations, 0% parameter documentation, and no merge/overwrite semantics leaves the agent without enough to invoke it confidently.

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% across 6 parameters; only titles and defaults appear in the schema. The description adds only that email is the identity key, leaving name, tags, notes, phone, and organization completely unexplained in both places.

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 pair (add or update) and resource (local contact), with the matching key (email) identified. It is distinguishable from list_contacts/search_contacts/delete_contact, though it never contrasts itself with import_correspondents, which is the closest sibling in scope.

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

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

No when-to-use guidance, no exclusions, no mention of alternatives such as import_correspondents for bulk additions or update paths for existing contacts. The agent must infer all routing decisions.

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