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

With no annotations, the description carries full burden but only states the action without disclosing behavioral traits. It doesn't mention if this is a mutation, requires specific permissions, has side effects, or how it interacts with other tools like 'get_auto_archive_list'. More context is needed for safe use.

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

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

The description is a single, efficient sentence with no wasted words. It is front-loaded and directly states the tool's function, making it easy to parse quickly.

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

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

Given the complexity of a mutation tool with no annotations and no output schema, the description is insufficient. It doesn't explain what 'auto-archive' means, how the list is used, or what the tool returns, leaving gaps in understanding its role and effects.

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

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

The schema has 100% description coverage, so parameters are well-documented in the schema itself. The description adds no additional meaning beyond implying the tool uses an email parameter, which aligns with the schema. This meets the baseline for high schema coverage.

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

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

The description clearly states the action ('Add') and resource ('sender to auto-archive list'), making the purpose understandable. However, it does not differentiate from its sibling 'remove_auto_archive_sender' or explain what 'auto-archive' entails, which prevents a perfect score.

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

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

No guidance is provided on when to use this tool versus alternatives like 'process_auto_archive' or 'reload_auto_archive', nor does it mention prerequisites such as authentication or connection state. The description lacks context for effective tool selection.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It states the action (move to Archive) but lacks details on permissions needed, whether the operation is reversible, effects on email flags/read status, error handling, or response format. This is inadequate for a mutation tool with zero annotation coverage.

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

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

The description is a single, efficient sentence with zero wasted words. It front-loads the core action and specifies the destination, making it easy to parse quickly.

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

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

For a mutation tool with no annotations and no output schema, the description is incomplete. It doesn't cover behavioral aspects like side effects, error cases, or what the tool returns, leaving significant gaps for an agent to use it correctly in context with many sibling tools.

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

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

Schema description coverage is 100%, so the schema fully documents parameters (uids, mailbox, archiveFolder). The description adds minimal value by implying default values for mailbox and archiveFolder, but doesn't explain parameter interactions or provide examples beyond what the schema offers.

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

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

The description clearly states the action ('Archive emails') and the resource ('emails'), specifying they are moved to the Archive folder. It distinguishes from siblings like 'move_email' by implying a default destination, but doesn't explicitly differentiate it from other archiving-related tools like 'add_auto_archive_sender' or 'process_auto_archive'.

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

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

No guidance is provided on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing connected mailboxes), exclusions, or comparisons to similar tools like 'move_email' (which might offer more flexibility) or archiving automation tools in the sibling list.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. While 'Login' implies authentication and potential session creation, it doesn't describe what happens after login (e.g., session persistence, token return, error handling), whether it's idempotent, or any rate limits/security considerations. This leaves significant gaps for a core authentication tool.

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

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

The description is a single, efficient sentence that gets straight to the point with zero wasted words. It's appropriately sized for a tool with clear parameters and no complex behavioral nuances needing explanation.

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 authentication tool with no annotations and no output schema, the description is insufficient. It doesn't explain what the tool returns (e.g., success status, session token, error messages), doesn't address security implications of passing credentials, and doesn't clarify the optional SMTP parameters' purpose. Given the complexity and critical nature of authentication, more context is needed.

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

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

Schema description coverage is 100%, so parameters are well-documented in the schema itself. The description adds minimal value beyond implying that username/password are for login, but doesn't clarify why optional SMTP parameters exist or their relationship to authentication versus other operations like 'save_draft'. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description 'Login with username and password' clearly states the action (login) and the required credentials, making the purpose immediately understandable. However, it doesn't differentiate this authentication tool from other connection-related tools like 'connect' or 'auto_connect' in the sibling list, which prevents a perfect score.

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 'connect' or 'auto_connect' from the sibling list. It also lacks information about prerequisites (e.g., whether this is for initial setup or recurring authentication) or when not to use it (e.g., if already authenticated).

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the credential source but lacks details on what happens on success/failure, whether it establishes a persistent session, error handling, or any side effects. This is inadequate for a connection tool with zero annotation coverage.

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

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

The description is a single, efficient sentence that front-loads the key information (action and credential source) with no wasted words. It is appropriately sized for a simple, parameterless 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?

Given the complexity of a connection operation, no annotations, and no output schema, the description is incomplete. It doesn't explain what the tool returns, error conditions, or behavioral traits like session management, which are critical for an agent to use it correctly.

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

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

The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description correctly states 'no parameters needed,' which adds value by clarifying this explicitly, aligning with the schema. A baseline of 4 is appropriate for zero-parameter tools.

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

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

The description clearly states the action ('Connect') and specifies the authentication method ('using config.json credentials'), which distinguishes it from the sibling 'connect' tool that likely requires explicit parameters. However, it doesn't explicitly mention what is being connected (e.g., to an email server), leaving some ambiguity.

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

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

The description implies usage when credentials are pre-configured in config.json, suggesting an alternative to parameter-based authentication. However, it doesn't explicitly state when NOT to use it (e.g., if config.json is missing) or compare it directly to the sibling 'connect' tool, leaving some context to inference.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It states what the tool does but doesn't describe what happens after connection establishment, whether authentication is required, error conditions, or what kind of connection state is created. For a connection tool with zero annotation coverage, this leaves significant behavioral questions unanswered.

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

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

The description is a single, efficient sentence that gets straight to the point with zero wasted words. It's appropriately sized for a straightforward connection tool and front-loads the essential information.

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

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

For a connection-establishing tool with no annotations and no output schema, the description is insufficient. It doesn't explain what the connection enables, what state changes occur, or what happens after connection. Given the complexity of establishing a network connection and the lack of structured behavioral information, more context is needed.

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

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

Schema description coverage is 100%, so the schema fully documents all three parameters. The description doesn't add any parameter-specific information beyond what's in the schema descriptions. This meets the baseline expectation when schema coverage is complete.

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

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

The description clearly states the action ('Establish') and resource ('IMAP connection to mail server'), making the purpose immediately understandable. It doesn't explicitly differentiate from sibling tools like 'authenticate' or 'auto_connect', but the specificity of 'IMAP connection' provides reasonable distinction.

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 'authenticate' or 'auto_connect'. It doesn't mention prerequisites, sequencing with other tools, or appropriate contexts for invocation.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action ('copy emails') but does not clarify whether this creates duplicates, preserves originals, requires specific permissions, or has side effects like updating timestamps. For a mutation tool with zero annotation coverage, this leaves critical behavioral traits unspecified.

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

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

The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It is front-loaded with the core action, making it easy for an agent to parse quickly and accurately.

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

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

For a mutation tool with no annotations and no output schema, the description is insufficient. It lacks details on behavioral outcomes (e.g., whether copying affects original emails, error conditions, or return values), leaving the agent with incomplete context to invoke the tool safely and effectively.

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 description coverage is 100%, with clear descriptions for all three parameters (uids, destination, mailbox). The description adds no additional semantic context beyond what the schema provides, such as format examples or constraints, so it meets the baseline for adequate but unenhanced parameter documentation.

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

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

The description clearly states the verb ('copy') and resource ('emails'), specifying the action of moving emails to another mailbox. However, it does not differentiate from sibling tools like 'move_email' or 'archive_email', which perform similar relocation operations but with different behavioral implications.

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

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

No guidance is provided on when to use this tool versus alternatives such as 'move_email' or 'archive_email'. The description lacks context about prerequisites (e.g., needing authentication or selecting a mailbox first) or exclusions, leaving the agent to infer usage from the tool 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 provided, the description carries full burden for behavioral disclosure. While 'Create' implies a write operation, it doesn't specify permission requirements, whether the operation is idempotent, what happens on duplicate names, or what the response contains. For a mutation tool with zero annotation coverage, this leaves significant behavioral questions unanswered.

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

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

The description is a single, efficient sentence that states the core purpose without unnecessary words. It's appropriately sized for a simple tool with one parameter and gets straight to the point.

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

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

For a mutation tool with no annotations and no output schema, the description is insufficient. It doesn't explain what happens after creation (e.g., success/failure response, whether the new mailbox becomes selected), doesn't mention potential constraints or side effects, and provides no context about the broader mailbox system.

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

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

The schema has 100% description coverage, with the single parameter 'mailbox' clearly documented as 'New mailbox name'. The description adds no additional parameter context beyond what's already in the schema, which meets the baseline expectation when schema coverage is complete.

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

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

The description clearly states the action ('Create') and resource ('new mailbox folder'), making the purpose immediately understandable. It doesn't differentiate from siblings like 'list_mailboxes' or 'select_mailbox', but the verb+resource combination is specific enough for basic understanding.

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's no mention of prerequisites (like authentication), when this operation is appropriate, or how it relates to sibling tools like 'list_mailboxes' or 'select_mailbox'.

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 burden. 'Close IMAP connection' indicates a destructive operation (terminates connection), but lacks details on effects (e.g., if pending operations are aborted, resource cleanup, error handling, or idempotency). It doesn't mention authentication state changes or 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?

Extremely concise with a single sentence 'Close IMAP connection' that is front-loaded and wastes no words. Every part of the description is essential and directly contributes to understanding the tool's purpose.

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 simplicity (0 parameters, no output schema, no annotations), the description is minimally adequate. However, as a destructive operation with no annotations, it should provide more behavioral context (e.g., what happens on close, error cases) to be fully complete for safe agent use.

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

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

The tool has 0 parameters, and schema description coverage is 100% (empty schema). The description doesn't need to add parameter details, so it meets the baseline of 4 for no parameters, though it could note that no inputs are required.

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

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

The description 'Close IMAP connection' clearly states the action (close) and resource (IMAP connection). It distinguishes from siblings like 'connect' (open) and 'auto_connect' (automatic open), but could be more specific about what 'close' entails (e.g., termination vs. cleanup).

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 on when to use this tool versus alternatives. It implies usage after an IMAP connection is established, but doesn't specify prerequisites (e.g., must be connected first), exclusions, or timing relative to other operations like 'stop_watch'.

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

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

With no annotations, the description carries full burden but provides minimal behavioral insight. It mentions the output format (base64) but omits critical details: whether it's a read-only operation, potential side effects (e.g., caching), error conditions, or performance implications. This is inadequate for a tool that likely involves data retrieval and encoding.

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

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

The description is extremely concise—a single phrase that front-loads the core purpose without unnecessary words. Every element ('Download', 'attachment content', 'base64') earns its place by conveying essential information efficiently, making it easy to parse quickly.

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

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

Given no annotations and no output schema, the description is incomplete. It lacks details on return values (beyond 'base64' hint), error handling, authentication needs, or operational constraints. For a tool with 3 parameters and potential complexity in email systems, this minimal description fails to provide sufficient context for safe and effective use.

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

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

Schema description coverage is 100%, so parameters are well-documented in the schema. The description adds no additional semantic context about parameters (e.g., explaining 'attachmentIndex' relevance or 'mailbox' defaults). It meets the baseline of 3 since the schema handles documentation, but doesn't enhance understanding beyond that.

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

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

The description clearly states the action ('Download') and resource ('attachment content'), specifying the format ('base64'). It distinguishes from siblings like 'get_attachments' (likely listing metadata) by focusing on content retrieval. However, it doesn't explicitly contrast with all potential alternatives, keeping it at 4 rather than 5.

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

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

No guidance is provided on when to use this tool versus alternatives like 'get_attachments' or 'get_email_body'. The description lacks context about prerequisites (e.g., needing email access) or exclusions, offering only basic functional intent without usage directives.

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 burden for behavioral disclosure. It states what the tool does but lacks critical details: whether this is a read-only operation, if it requires authentication, potential rate limits, what happens if filters yield no results, or the format of returned data. For a tool with 5 parameters and no output schema, this is a significant gap.

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

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

The description is a single, efficient sentence that immediately conveys the core functionality. Every word earns its place with no redundancy or unnecessary elaboration.

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 5 parameters, no annotations, and no output schema, the description is inadequate. It doesn't explain what 'fetch' means operationally, how results are returned, error conditions, or relationships with sibling tools. The agent would struggle to use this effectively without trial and error.

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

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

Schema description coverage is 100%, so parameters are well-documented in the schema itself. The description adds minimal value beyond stating 'optional filters' - it doesn't explain filter relationships, precedence, or provide examples. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the action ('fetch emails') and resource ('from mailbox'), making the purpose immediately understandable. It distinguishes from many siblings that perform different operations (e.g., search_emails, get_email, list_mailboxes). However, it doesn't explicitly differentiate from search_emails which might also retrieve emails with filters.

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

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

The description mentions 'optional filters' but provides no guidance on when to use this tool versus alternatives like search_emails, get_email, or list_mailboxes. There's no mention of prerequisites, context, or exclusions, leaving the agent to guess based on tool names 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 provided, the description carries full burden for behavioral disclosure. It states the action but doesn't cover critical aspects like whether this is a mutating operation, what permissions are required, how it affects email state, or error handling. This leaves significant gaps in understanding the tool's behavior.

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

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

The description is extremely concise at just four words, with zero wasted language. It's front-loaded with the core action and resource, making it immediately clear what the tool does without unnecessary elaboration.

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 mutating tool with no annotations and no output schema, the description is insufficient. It doesn't explain what happens after flagging (e.g., success indicators, error responses), doesn't mention side effects, and provides minimal context about the operation's scope or limitations.

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

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

Schema description coverage is 100%, so parameters are well-documented in the schema itself. The description adds no additional semantic context about parameters beyond what's in the schema, such as explaining flag naming conventions or mailbox selection implications, meeting the baseline for adequate coverage.

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

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

The description clearly states the action ('Add flag') and target resource ('emails'), making the purpose immediately understandable. It doesn't differentiate from its sibling 'unflag_email' or specify what types of flags can be added, which prevents a perfect score.

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 'search_flagged' or 'unflag_email'. It doesn't mention prerequisites, such as needing email UIDs from prior operations like 'fetch_emails' or 'search_emails', leaving usage context unclear.

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 states the action ('List attachments') but does not describe what the output includes (e.g., file names, sizes, types), whether it requires authentication, or if there are rate limits. This is a significant gap for a tool with no structured behavioral hints.

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

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

The description is a single, efficient sentence with no wasted words. It is front-loaded with the core action, making it easy to grasp quickly. Every part of the sentence contributes directly to stating the tool's purpose.

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 complexity of listing attachments (which could involve multiple data points) and the lack of annotations and output schema, the description is incomplete. It does not explain what information is returned (e.g., attachment metadata), leaving the agent uncertain about the tool's full behavior and output.

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

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

Schema description coverage is 100%, so the input schema already documents the parameters ('uid' and 'mailbox') fully. The description does not add any meaning beyond this, such as explaining what an email UID is or how mailbox names are formatted. Baseline 3 is appropriate as the schema handles the heavy lifting.

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

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

The description 'List attachments of an email' clearly states the verb ('List') and resource ('attachments of an email'), making the purpose understandable. However, it does not distinguish this tool from sibling tools like 'download_attachment' or 'get_email', which might also involve attachments or email data, so it lacks explicit differentiation.

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

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

The description provides no guidance on when to use this tool versus alternatives. For example, it does not specify if this should be used before downloading attachments or as part of email retrieval, nor does it mention prerequisites like needing an email UID. This leaves usage context unclear.

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 states the action but lacks details on permissions, rate limits, side effects, or response format. For a read operation with zero annotation coverage, this is a significant gap in transparency.

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

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

The description is a single, efficient sentence that directly states the tool's purpose without any wasted words. It is front-loaded and appropriately sized for a simple tool, making it easy to parse quickly.

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

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

Given the lack of annotations and output schema, the description is incomplete. It doesn't explain what the returned list contains (e.g., sender details, format) or any behavioral aspects like error handling. For a tool with no structured data beyond the input schema, more context is needed to be fully helpful.

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

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

The input schema has 0 parameters with 100% coverage, so the schema fully documents the absence of inputs. The description doesn't need to add parameter details, and it correctly implies no inputs are required, aligning with the schema. A baseline of 4 is appropriate as it doesn't contradict 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 clearly states the verb 'Get' and the resource 'list of senders that are auto-archived', making the purpose specific and understandable. However, it doesn't explicitly differentiate from sibling tools like 'reload_auto_archive' or 'process_auto_archive', which might involve similar concepts, so it doesn't reach a perfect score.

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. It doesn't mention prerequisites, context, or exclusions, such as whether it requires prior setup or differs from other list-related tools like 'list_mailboxes'. This leaves the agent with minimal 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 burden of behavioral disclosure. It mentions the data source ('in-memory cache'), which is useful context, but doesn't describe what 'overview' includes (e.g., summary counts, metadata), cache staleness, performance implications, or error behavior. For a read operation with zero annotation coverage, this leaves significant gaps in understanding how the tool 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 a single, efficient sentence that front-loads the key information ('Get cached email overview') and specifies the scope. Every word earns its place, with no redundant or vague phrasing, making it easy to parse quickly.

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

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

Given the tool has 2 parameters with full schema coverage and no output schema, the description is minimally complete for a read operation. It clarifies the cache aspect but lacks details on output format, error handling, or cache behavior. With no annotations to supplement, this leaves the agent with incomplete context for reliable use, though the core purpose is 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 100%, so the schema already fully documents both parameters (mailbox with enum values and limit with default). The description adds no additional parameter semantics beyond implying the tool can handle multiple mailboxes ('or omit for all' is in the schema). Baseline 3 is appropriate as the schema does the heavy lifting, but the description doesn't enhance parameter understanding.

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

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

The description clearly states the action ('Get cached email overview') and specifies the target resources (INBOX, next, waiting, someday) with the source (in-memory cache). It distinguishes from siblings by focusing on cached overview rather than raw email data or operations like search_emails or get_email. However, it doesn't explicitly differentiate from get_mailbox_status or get_total_count, which might provide related but different information.

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. It doesn't mention when to prefer this cached overview over fetching emails directly (e.g., fetch_emails), when cache freshness matters, or how it relates to siblings like get_mailbox_status or get_total_count. The agent must infer usage from the name and description 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 provided, the description carries the full burden of behavioral disclosure. It states the tool retrieves a 'complete email', implying a read-only operation, but doesn't cover critical aspects like authentication requirements, error handling (e.g., invalid UID), rate limits, or what 'complete' entails (e.g., includes attachments, headers, body). For a tool with zero annotation coverage, this is a significant gap in transparency.

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

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

The description is a single, efficient sentence that front-loads the core purpose ('Get complete email by UID') with zero wasted words. It's appropriately sized for a straightforward retrieval tool, making it easy for an agent to parse quickly without unnecessary elaboration.

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 complexity (a read operation with 2 parameters), lack of annotations, and no output schema, the description is incomplete. It doesn't explain what 'complete email' returns (e.g., format, fields), error conditions, or dependencies like authentication. For a tool in this context, more detail is needed to guide the agent effectively, especially without structured support from annotations or 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?

The schema description coverage is 100%, with both parameters ('uid' and 'mailbox') well-documented in the schema itself. The description adds no additional parameter semantics beyond implying the 'uid' is used to identify the email. Since the schema does the heavy lifting, the baseline score of 3 is appropriate, as the description doesn't compensate but also doesn't detract from the schema's clarity.

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

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

The description clearly states the action ('Get complete email') and target resource ('by UID'), making the purpose immediately understandable. It distinguishes itself from siblings like 'get_email_body' or 'get_email_headers' by specifying 'complete email'. However, it doesn't explicitly contrast with 'fetch_emails' (which likely retrieves multiple emails) or 'get_thread' (which might retrieve conversation threads), leaving some sibling differentiation incomplete.

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. It doesn't mention prerequisites (e.g., needing authentication or connection), compare it to similar tools like 'fetch_emails' for bulk retrieval or 'get_email_body' for partial content, or specify use cases (e.g., for detailed viewing vs. overview). This leaves the agent with minimal context for tool selection.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action ('get') but doesn't cover critical aspects like whether this is a read-only operation, authentication requirements, rate limits, error handling, or what happens if the UID doesn't exist. For a tool with no annotation coverage, this leaves significant gaps in understanding its behavior.

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

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

The description is extremely concise at just three words ('Get email body content'), with zero wasted language. It's front-loaded and gets straight to the point, making it easy for an agent to parse quickly.

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

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

Given the complexity of email retrieval (with multiple sibling tools), no annotations, and no output schema, the description is insufficient. It doesn't explain what 'body content' entails (e.g., plain text vs. HTML, attachments), how it relates to other email tools, or what the return value looks like. The agent would need to guess or rely heavily on the schema alone.

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

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

The input schema has 100% description coverage, with clear documentation for all three parameters (uid, mailbox, format). The description adds no additional parameter semantics beyond what's in the schema, such as explaining the relationship between parameters or usage examples. This meets the baseline for high schema coverage.

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 'Get email body content' clearly states the verb (get) and resource (email body content), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'get_email' or 'get_email_headers', which likely retrieve different parts of an email, so it falls short of a perfect score.

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 such as 'get_email' (which might return full email data) or 'get_email_headers'. There's no mention of prerequisites, context, or exclusions, leaving the agent to infer usage from the tool 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?

No annotations are provided, so the description carries full burden. It mentions 'faster' as a behavioral trait, which is useful, but lacks critical details: it doesn't specify if this is a read-only operation, what permissions are required, how errors are handled, or the format/structure of returned headers. For a tool with no annotation coverage, this leaves significant gaps in understanding its behavior.

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

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

The description is extremely concise—a single phrase with no wasted words. It's front-loaded with the core purpose ('Get only email headers') and includes a useful qualifier ('faster'). Every part of the description earns its place by adding value.

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

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

Given no annotations, no output schema, and a tool that likely returns structured data (email headers), the description is incomplete. It doesn't explain what headers are returned, the response format, or any behavioral constraints. For a tool with two parameters and no structured output documentation, this leaves too much unspecified for reliable use.

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

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

Schema description coverage is 100%, so the schema fully documents both parameters (uid and mailbox). The description adds no additional parameter information beyond what's in the schema, such as explaining what 'uid' represents in context or default behavior for 'mailbox'. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the action ('Get') and resource ('email headers'), making the purpose understandable. It distinguishes itself from siblings like 'get_email' or 'get_email_body' by specifying 'only email headers', but doesn't explicitly name these alternatives or explain the functional difference beyond speed.

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 with '(faster)', suggesting this tool should be chosen over full email retrieval when speed is prioritized and only headers are needed. However, it doesn't explicitly state when to use this versus alternatives like 'get_email' or 'get_email_body', nor does it mention prerequisites or exclusions.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It states this is a 'Get' operation, implying read-only behavior, but doesn't specify whether it requires authentication, has rate limits, returns real-time or cached data, or what format the output takes. The description is minimal and lacks critical operational context for a tool that likely interacts with a mail system.

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

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

The description is extremely concise at just 7 words, with zero wasted language. It's front-loaded with the core purpose and includes helpful examples of what 'status' includes. Every word earns its place in this minimal but complete statement of function.

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 moderate complexity (retrieving status from a mail system), lack of annotations, and no output schema, the description is insufficiently complete. It doesn't explain what specific status fields are returned, whether authentication is required, if there are any side effects, or how errors are handled. For a tool with no structured behavioral metadata, this description leaves too many operational questions unanswered.

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

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

The input schema has 100% description coverage, with the single parameter 'mailbox' clearly documented as 'Mailbox name'. The description adds no additional parameter information beyond what's in the schema. According to scoring rules, when schema_description_coverage is high (>80%), the baseline is 3 even with no param info in the description.

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

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

The description clearly states the tool's purpose with a specific verb ('Get') and resource ('mailbox status'), and specifies what information is retrieved ('message count, unseen, etc.'). It distinguishes itself from sibling tools like 'get_unread_count' by providing broader status information, though it doesn't explicitly differentiate from 'list_mailboxes' which might provide some overlapping data.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when to choose this over 'get_unread_count' for just unread counts, 'list_mailboxes' for mailbox listings, or 'get_total_count' for total messages. There are no prerequisites, exclusions, or context provided for usage decisions.

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 burden for behavioral disclosure. 'Get' implies a read operation, but the description doesn't specify whether this requires authentication, what format the thread data returns in, whether it includes attachments, or if there are rate limits. This leaves significant behavioral questions unanswered.

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

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

The description is extremely concise at just three words, with zero wasted language. It's front-loaded with the core purpose and uses minimal syntax. Every word earns its place by communicating essential information about the tool's function.

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

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

For a tool with no annotations and no output schema, the description is insufficiently complete. It doesn't explain what constitutes a 'thread/conversation', what data is returned, how the tool behaves with invalid UIDs, or how it relates to similar email retrieval tools in the sibling set. The agent would have significant gaps in understanding how to properly use this tool.

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

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

Schema description coverage is 100%, so the schema already documents both parameters thoroughly. The description adds no additional parameter semantics beyond what's in the schema - it doesn't explain what 'uid' represents in context of threads, how mailbox selection affects results, or provide examples of valid values.

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

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

The description clearly states the verb ('Get') and resource ('email thread/conversation'), making the purpose immediately understandable. However, it doesn't differentiate this tool from sibling tools like 'get_email' or 'get_email_body', which also retrieve email-related data but target different resources.

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. With siblings like 'get_email', 'get_email_body', and 'get_email_headers' that retrieve specific email components, there's no indication whether this tool retrieves the full conversation thread or how it differs from those other retrieval tools.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states what the tool does but doesn't reveal any behavioral traits—such as whether it's a read-only operation, if it requires specific permissions, potential rate limits, or what the return format looks like. For a tool with zero annotation coverage, this is a significant gap in transparency.

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

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

The description is a single, efficient sentence with zero wasted words. It's front-loaded with the core purpose and appropriately sized for a simple tool, making it easy for an agent to parse quickly without unnecessary elaboration.

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 lack of annotations and output schema, the description is incomplete. It doesn't explain what the tool returns (e.g., a numeric count, error conditions, or format details) or any behavioral nuances. For a tool with no structured data to rely on, the description should provide more context to ensure the agent can use it correctly.

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

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

The description doesn't add any parameter-specific information beyond what's in the input schema, which has 100% coverage (the 'mailbox' parameter is fully described). Since schema coverage is high, the baseline score is 3, as the description doesn't need to compensate but also doesn't enhance parameter understanding with additional context or examples.

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

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

The description clearly states the verb ('Get') and resource ('total email count in mailbox'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'get_unread_count' or 'get_mailbox_status' which also retrieve mailbox metrics, leaving some ambiguity about when to choose this specific tool.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'get_unread_count' or 'get_mailbox_status'. It doesn't mention prerequisites (e.g., whether authentication is required) or contextual factors that might influence tool selection, leaving the agent to infer usage from the tool 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states what the tool does but doesn't mention any behavioral traits such as whether it requires authentication, has rate limits, returns cached or real-time data, or how it handles errors. This is a significant gap for a tool with no annotation coverage.

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

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

The description 'Get count of unread emails' is a single, efficient sentence that front-loads the core purpose with zero waste. It's appropriately sized for a simple tool and earns its place by clearly stating the action and target.

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

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

Given no annotations and no output schema, the description is incomplete. It doesn't explain what the return value looks like (e.g., a number, an object with metadata), any prerequisites like authentication, or error conditions. For a tool in a complex email management context, this leaves too much 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?

The input schema has 100% description coverage, with the 'mailbox' parameter documented as 'Mailbox name (default: INBOX)'. The description doesn't add any parameter semantics beyond this, so it meets the baseline of 3 where the schema does the heavy lifting without compensating for gaps.

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

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

The description 'Get count of unread emails' clearly states the verb ('Get count') and resource ('unread emails'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'search_unread' or 'get_total_count', which might provide overlapping functionality, so it doesn't reach the highest score.

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. With siblings like 'search_unread' and 'get_total_count' available, there's no indication of whether this tool is for quick counts, filtered counts, or specific contexts, leaving the agent to guess based on tool names 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 provided, the description carries full burden for behavioral disclosure. It mentions the tool is 'temporary' (implying it may stop after timeout or session end) and uses IMAP IDLE (a push protocol), which adds some context. However, it doesn't describe what happens during/after watching (e.g., how new emails are reported, if it blocks other operations, error handling, or resource implications), leaving significant gaps for a tool that likely involves ongoing monitoring.

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 front-loaded with the core purpose in a single sentence. The parenthetical '(IMAP IDLE)' and suffix '- single mailbox, temporary' add useful context efficiently. There's no wasted text, though it could be slightly more structured (e.g., separating scope notes).

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 (ongoing monitoring with IMAP IDLE), no annotations, no output schema, and 2 parameters, the description is incomplete. It lacks details on behavior during/after execution, error conditions, interaction with other tools (e.g., 'stop_watch'), and what the agent should expect as a result. This is inadequate for a tool that likely involves stateful operations.

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

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

Schema description coverage is 100%, so the schema already documents both parameters (mailbox and timeout) with descriptions and defaults. The description adds no additional parameter semantics beyond what's in the schema, such as explaining valid mailbox formats or timeout behavior specifics. Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description clearly states the tool's purpose: 'Start watching mailbox for new emails (IMAP IDLE) - single mailbox, temporary'. It specifies the action (start watching), resource (mailbox/emails via IMAP IDLE), and scope (single, temporary). However, it doesn't explicitly distinguish from sibling tools like 'start_watch' or 'stop_watch', which appear to be related.

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 minimal usage guidance. It mentions 'single mailbox, temporary' which gives some context about scope and duration, but offers no explicit guidance on when to use this tool versus alternatives like 'start_watch' or 'stop_watch', nor does it mention prerequisites (e.g., connection/authentication state).

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

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

No annotations are provided, so the description carries full burden for behavioral disclosure. It states it lists folders but doesn't mention whether this is a read-only operation, if it requires authentication, how results are returned (e.g., pagination), or any rate limits. This leaves significant gaps for a tool that likely interacts with a mail system.

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

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

The description is a single, efficient sentence with zero waste. It's front-loaded with the core action and resource, making it easy to parse quickly without unnecessary elaboration.

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 lack of annotations and output schema, the description is incomplete for a tool that lists folders. It doesn't explain what the output looks like (e.g., list of folder names, metadata), potential errors, or dependencies like needing to be connected first. This is inadequate for proper agent usage.

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

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

Schema description coverage is 100%, so the schema already documents the optional 'pattern' parameter. The description adds no additional meaning about parameters beyond what's in the schema, such as examples of filter patterns or how they're applied. This meets the baseline for high schema coverage.

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

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

The description clearly states the verb ('List') and resource ('all mailbox folders'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'select_mailbox' or 'get_mailbox_status', which also involve mailbox operations, so it doesn't reach the highest clarity level.

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. With many sibling tools like 'select_mailbox' or 'get_mailbox_status' that might overlap in mailbox-related contexts, there's no explicit or implied direction on usage scenarios 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 states the action ('Mark emails as read') but lacks details on permissions required, whether the change is reversible, effects on email metadata, error handling, or confirmation of success. For a mutation tool with zero annotation coverage, this is a significant gap in behavioral disclosure.

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

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

The description is a single, direct sentence with zero waste—'Mark emails as read'—making it highly concise and front-loaded. Every word contributes to the core purpose without redundancy or unnecessary elaboration.

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 mutation nature, lack of annotations, and no output schema, the description is incomplete. It does not address behavioral aspects like side effects, error cases, or return values, leaving gaps that could hinder an AI agent's correct invocation in a real-world 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?

The schema description coverage is 100%, with clear parameter descriptions in the schema (e.g., 'Email UIDs' for 'uids', 'Mailbox name (default: current)' for 'mailbox'). The description adds no additional meaning beyond the schema, such as explaining UID formats or mailbox naming conventions, but the high schema coverage justifies the baseline score.

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

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

The description 'Mark emails as read' clearly states the verb ('Mark') and resource ('emails') with the specific action ('as read'). It distinguishes from sibling tools like 'mark_unread' by specifying the opposite state, though it doesn't explicitly contrast with other email-modification tools like 'archive_email' or 'flag_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 guidance is provided on when to use this tool versus alternatives. The description does not mention prerequisites (e.g., needing email UIDs from a prior fetch), exclusions, or comparisons to siblings like 'mark_unread' or 'flag_email' for similar email-state operations.

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 burden for behavioral disclosure. While 'mark emails as unread' implies a state mutation, it doesn't specify whether this requires authentication, what permissions are needed, whether the operation is reversible, or what happens on success/failure. No rate limits, side effects, or error conditions are mentioned.

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

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

The description is a single, efficient sentence with zero waste. It's front-loaded with the core purpose and contains no unnecessary words or redundant information.

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

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

For a state mutation tool with no annotations and no output schema, the description is insufficient. It doesn't explain what the tool returns, what happens on success/failure, or any behavioral constraints. Given the complexity of email state management and the lack of structured metadata, more context is needed about how this operation interacts with the email system.

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

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

Schema description coverage is 100%, so the schema already documents both parameters (uids and mailbox). The description doesn't add any parameter-specific information beyond what's in the schema, such as explaining what UIDs represent or how the mailbox parameter affects the operation. Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description clearly states the verb ('mark') and resource ('emails') with the specific state change ('as unread'). It distinguishes from the sibling 'mark_read' by specifying the opposite state, but doesn't explicitly differentiate from other email state manipulation tools like 'flag_email' or 'archive_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 guidance is provided about when to use this tool versus alternatives. The description doesn't mention prerequisites (like needing to fetch emails first), when this operation is appropriate, or what happens if emails are already unread. It also doesn't reference the sibling 'mark_read' for the opposite operation.

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

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

No annotations are provided, so the description carries full burden. It states the action ('move') but doesn't disclose behavioral traits: it doesn't specify if this is destructive (emails removed from source), permission requirements, error handling (e.g., invalid UIDs), or side effects. For a mutation tool with zero annotation coverage, this is a significant gap in transparency.

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

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

The description is a single, efficient sentence with zero waste. It's front-loaded with the core action and resource, making it easy to parse. Every word earns its place by conveying the essential purpose without redundancy.

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

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

Given the tool's complexity (mutation operation with 3 parameters), lack of annotations, and no output schema, the description is incomplete. It doesn't cover behavioral aspects like effects on source mailbox, error cases, or return values. For a tool that modifies email state, more context is needed to ensure safe and correct usage.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters (uids, destination, mailbox) with descriptions. The description adds no additional meaning beyond what the schema provides, such as format examples or constraints. Baseline 3 is appropriate when schema does the heavy lifting, but no extra value 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?

The description clearly states the action ('move') and resource ('emails'), specifying the destination ('to another mailbox'). It distinguishes from copy_email by implying relocation rather than duplication, though not explicitly. However, it lacks specific differentiation from other sibling tools like archive_email or select_mailbox, which could involve similar mailbox operations.

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. It doesn't mention prerequisites (e.g., needing UIDs from fetch_emails), exclusions (e.g., not for archiving), or comparisons to siblings like copy_email (move vs. copy) or archive_email (move to archive vs. general mailbox). Usage is implied but not articulated.

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 behavioral traits: the tool archives emails automatically based on a sender list, and the dry_run option allows previewing. However, it lacks details on permissions needed, rate limits, error handling, or what 'listed senders' refers to (likely from 'get_auto_archive_list').

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

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

The description is two sentences with zero waste: the first states the core purpose, and the second provides crucial usage guidance for the parameter. It is front-loaded with the main action and efficiently covers essential information without redundancy.

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

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

Given no annotations and no output schema, the description is reasonably complete for a tool with one parameter. It covers purpose, usage, and parameter behavior. However, it could improve by mentioning dependencies (e.g., sender list from 'get_auto_archive_list') or output format, but the simplicity of the tool makes it mostly adequate.

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

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

The input schema has 100% description coverage, so the baseline is 3. The description adds value by explaining the practical use of the 'dry_run' parameter ('to preview without moving'), which enhances understanding beyond the schema's technical definition. With only one parameter, this extra context is sufficient for a higher score.

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

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

The description clearly states the tool's purpose with a specific verb ('process'), resource ('INBOX'), and action ('archive emails from listed senders'). It distinguishes from siblings like 'archive_email' (manual archiving) and 'get_auto_archive_list' (listing senders) by emphasizing automated processing based on a predefined sender list.

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

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

The description provides explicit usage guidance: it specifies when to use the tool (to process and archive emails from listed senders) and when to use the dry_run parameter (to preview without moving). It implicitly distinguishes from alternatives like 'archive_email' (which archives specific emails) and 'search_by_sender' (which finds emails without archiving).

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 burden but offers minimal behavioral insight. It implies a write/mutation operation ('Force refresh') but doesn't disclose side effects (e.g., performance impact, temporary unavailability), authentication needs, rate limits, or what 'force' entails versus normal refresh cycles.

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

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

The description is a single, efficient sentence with no wasted words. It's front-loaded with the core action and scope, making it immediately understandable without unnecessary elaboration.

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

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

For a mutation tool with no annotations and no output schema, the description is inadequate. It lacks details on what 'force refresh' entails operationally, expected outcomes, error conditions, or how it interacts with sibling tools like 'fetch_emails' or 'get_cached_overview'.

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 schema description coverage is 100% (empty schema). The description appropriately doesn't discuss parameters, and the baseline for zero parameters is 4, as there's no need to compensate for missing param documentation.

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

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

The description clearly states the action ('Force refresh') and target resource ('email cache for all watched mailboxes'), making the tool's purpose understandable. It doesn't explicitly differentiate from siblings like 'get_cached_overview' or 'fetch_emails', but the 'force refresh' verb suggests an administrative/background operation rather than data retrieval.

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

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

No guidance is provided on when to use this tool versus alternatives. The description doesn't mention prerequisites (e.g., needing watched mailboxes), frequency considerations, or what triggers might warrant a forced refresh versus relying on automatic caching.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions reloading from a file after manual edit, but lacks details on permissions needed, potential side effects (e.g., if it disrupts ongoing processes), error handling, or response format. For a mutation tool with zero annotation coverage, this is a significant gap.

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

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

The description is a single, efficient sentence that front-loads the key action and context without any wasted words. It effectively communicates the core purpose in a minimal format, making it highly concise and 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?

Given the tool has 0 parameters and no output schema, the description is adequate for basic understanding but incomplete for a mutation tool with no annotations. It should ideally cover behavioral aspects like safety, effects, or error cases to be fully helpful, leaving room for improvement.

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

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

The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description adds context about the action being triggered 'after manual edit,' which provides useful semantic insight beyond the schema, justifying a score above the baseline of 3 for high schema coverage.

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

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

The description clearly states the action ('reload') and the resource ('auto-archive config from file'), making the purpose specific and understandable. However, it doesn't explicitly differentiate from siblings like 'process_auto_archive' or 'get_auto_archive_list', which could help clarify its unique role in the toolset.

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

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

The description implies usage context ('after manual edit'), suggesting it should be used post-editing, but it doesn't provide explicit guidance on when to choose this tool over alternatives like 'process_auto_archive' or warn against misuse. This leaves some ambiguity in tool selection.

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

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

With no annotations provided, the description carries full burden but only states the basic action. It doesn't disclose behavioral traits such as whether this requires specific permissions, if it's reversible, what happens on success/failure, or any rate limits. This leaves significant 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?

The description is a single, direct sentence with zero waste—it efficiently conveys the core action without unnecessary words. It's appropriately sized and front-loaded for quick 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?

For a mutation tool with no annotations and no output schema, the description is incomplete. It doesn't explain what the tool returns, error conditions, or side effects, leaving the agent with insufficient context to use it effectively beyond the basic action.

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

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

Schema description coverage is 100%, so the input schema fully documents the 'email' parameter. The description adds no additional meaning beyond implying the email must be in the auto-archive list, which is minimal value. Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description clearly states the action ('Remove') and resource ('sender from auto-archive list'), making the purpose immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'get_auto_archive_list' or 'reload_auto_archive', which prevents a perfect score.

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

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

No guidance is provided on when to use this tool versus alternatives like 'get_auto_archive_list' for checking the list or 'process_auto_archive' for related operations. The description lacks context about prerequisites (e.g., needing the sender to be in the list first) or exclusions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions automatic signature inclusion, which adds some context, but fails to cover critical aspects like whether this is a mutation (implied by 'save'), permission requirements, rate limits, or what happens on failure (e.g., if the drafts folder doesn't exist). For a write operation with zero annotation coverage, this is insufficient.

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

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

The description is a single, efficient sentence that front-loads the core purpose ('Save email as draft') and adds a useful detail about signature inclusion. There is no wasted verbiage or redundancy, making it highly concise and 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?

Given the tool's complexity (8 parameters, mutation operation) and lack of annotations or output schema, the description is moderately complete. It covers the basic purpose and a key behavioral trait (signature inclusion), but gaps remain in usage guidelines, full behavioral transparency, and output details. It's adequate but has clear room for improvement.

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

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

Schema description coverage is 100%, so the schema fully documents all 8 parameters. The description adds minimal value beyond the schema by hinting at signature behavior related to the 'includeSignature' parameter, but doesn't provide additional syntax or format details. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the specific action ('Save email as draft') and resource ('email'), distinguishing it from siblings like 'send_email' (not present) or 'archive_email' by focusing on draft creation. It adds unique detail about automatic signature inclusion from config.

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

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

No guidance on when to use this tool versus alternatives is provided. For example, it doesn't mention when to choose this over a 'send_email' tool (if available) or other email-related operations like 'archive_email' or 'move_email' from the sibling list. The description only states what it does, not when it's 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool searches emails by date range but doesn't reveal critical behaviors: whether it's read-only or mutative (though 'search' implies read-only), if it requires authentication, rate limits, pagination handling (beyond the 'limit' parameter), or what the output format looks like. For a search tool with zero annotation coverage, this leaves significant gaps in understanding its 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 a single, efficient sentence that front-loads the core functionality ('Search emails by date range') with zero wasted words. It's appropriately sized for a straightforward search tool, making it easy for an agent to parse quickly.

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

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

Given the tool's moderate complexity (4 parameters, no output schema, no annotations), the description is incomplete. It lacks details on behavioral traits (e.g., read-only nature, authentication needs), usage context versus siblings, and output expectations. While the schema covers parameters well, the overall context for safe and effective tool invocation is insufficient, especially without annotations to fill gaps.

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

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

The input schema has 100% description coverage, with clear parameter definitions (e.g., 'since' and 'before' as ISO dates, 'mailbox' with default, 'limit' with default). The description adds no additional parameter semantics beyond what the schema provides—it doesn't explain date format nuances, mailbox selection implications, or result ordering. With high schema coverage, the baseline score of 3 is appropriate, as the schema does the heavy lifting.

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

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

The description clearly states the tool's purpose with a specific verb ('Search') and resource ('emails'), and specifies the search criterion ('by date range'). It distinguishes itself from siblings like search_by_sender or search_by_subject by focusing on date-based filtering. However, it doesn't explicitly differentiate from the more generic 'search_emails' tool, which might also support date parameters.

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. It doesn't mention whether it's for date-specific queries only, how it compares to 'search_emails' (which might handle broader searches), or any prerequisites like authentication. Without such context, the agent must infer usage from the tool 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. While 'Search' implies a read-only operation, the description doesn't address important behavioral aspects like whether this is a real-time search or cached search, what permissions are required, whether it searches across all mailboxes or just the specified one, what the return format looks like, or any rate limits. The description only states what the tool does, not 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 perfectly concise at just 5 words: 'Search emails by sender address'. Every word earns its place - it specifies the action (search), the resource (emails), and the filtering criteria (by sender address). There's zero waste or redundancy.

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

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

For a search tool with 3 parameters, no annotations, and no output schema, the description is insufficient. It doesn't explain what the tool returns (email objects, IDs, summaries?), whether results are paginated, how the search is performed (full-text, exact match, substring?), or any error conditions. The description only states the basic purpose without providing the context needed for effective use.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters thoroughly. The description adds no additional parameter semantics beyond what's in the schema - it doesn't explain how the sender parameter handles partial matches, case sensitivity, or what happens with ambiguous names. With complete schema coverage, the baseline score of 3 is appropriate.

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

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

The description clearly states the tool's purpose as 'Search emails by sender address', which is a specific verb+resource combination. It distinguishes itself from generic search tools like 'search_emails' by focusing specifically on sender-based filtering, though it doesn't explicitly differentiate from 'search_by_date' or 'search_by_subject' which are similar specialized search tools.

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

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

The description provides no guidance on when to use this tool versus alternatives. There are multiple search-related sibling tools (search_by_date, search_by_subject, search_emails, search_flagged, search_unread), but the description doesn't indicate when sender-based searching is preferred over other search methods or when to use the more generic 'search_emails' tool instead.

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. The description only states what the tool does (search emails by subject) without revealing any behavioral traits like whether this is a read-only operation, what permissions are required, how results are returned, whether there are rate limits, or what happens when no matches are found.

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

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

The description is extremely concise at just three words, front-loading the essential information with zero wasted words. Every word earns its place by specifying the action (search), target (emails), and criteria (by subject).

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 search tool with no annotations and no output schema, the description is inadequate. It doesn't explain what the tool returns (email objects, IDs, summaries), how results are structured, whether there's pagination, or any error conditions. The description provides only the most basic functional statement without the context needed for effective tool selection and 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 100%, so the schema already documents all three parameters (subject, mailbox, limit) with their types and descriptions. The description adds no additional parameter information beyond what's in the schema, maintaining the baseline score of 3 for high schema coverage.

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 as searching emails by subject, which is a specific verb+resource combination. However, it doesn't distinguish this tool from sibling search tools like search_by_date, search_by_sender, search_emails, or search_unread, which all search emails but with different criteria.

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. With multiple sibling search tools available (search_by_date, search_by_sender, search_emails, search_unread, search_flagged), there's no indication of when subject-based searching is appropriate versus other search criteria or general email searching.

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 burden. It only states the action without disclosing behavioral traits like whether this is a read-only operation, what permissions are needed, how results are returned (e.g., pagination, format), or any rate limits. For a search tool with no annotation coverage, this is inadequate.

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

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

The description is extremely concise at four words, with no wasted text. However, it's arguably too brief given the complexity of the tool and lack of sibling differentiation, bordering on under-specification rather than optimal 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?

Given the tool has 3 parameters, no annotations, no output schema, and many sibling alternatives, the description is incomplete. It doesn't explain what the tool returns, how to interpret results, or when to choose it over other search tools. This leaves significant gaps for an agent to use it effectively.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters (query, mailbox, limit) with their types and default values. The description adds no additional meaning beyond implying a search action, which is already clear from the tool name. This meets the baseline for high schema coverage.

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 'Search emails with query' states the basic action (search) and resource (emails), but it's vague about scope and doesn't distinguish from many sibling search tools like search_by_date, search_by_sender, search_by_subject, search_flagged, or search_unread. It mentions 'query' but doesn't clarify what kind of search this performs compared to the specialized 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?

No guidance is provided on when to use this tool versus the many sibling search alternatives. The description doesn't mention any prerequisites, context, or exclusions, leaving the agent to guess based on tool names alone. This is a significant gap given the server has multiple specialized search tools.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states what the tool does but lacks critical details like whether this is a read-only operation, if it requires authentication, how results are ordered, or if there are rate limits. For a search tool with zero annotation coverage, this is a significant gap.

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

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

The description is a single, efficient sentence with zero waste. It's front-loaded with the core purpose and appropriately sized for a simple search tool, making it easy to parse quickly.

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

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

Given the tool's low complexity (2 optional parameters, no output schema, no annotations), the description is minimally adequate but incomplete. It explains what the tool does but lacks behavioral context (e.g., safety, performance) and usage guidance relative to siblings, which are needed for full agent understanding.

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

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

The input schema has 100% description coverage, with clear documentation for both parameters ('mailbox' and 'limit'). The description adds no additional parameter semantics beyond what's in the schema, so it meets the baseline of 3 where the schema does the heavy lifting.

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

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

The description clearly states the tool's purpose with a specific verb ('Get') and resource ('flagged/starred emails'), making it immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'search_emails' or 'search_unread', which are similar search operations but with different filters.

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. With many sibling search tools (e.g., 'search_emails', 'search_by_subject'), there's no indication of when this specific flagged email search is preferred or what distinguishes it from broader searches.

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 burden for behavioral disclosure. It states it 'gets' emails (implying a read operation) but doesn't cover critical aspects like whether this is a safe operation, if it requires authentication, what the return format is (e.g., list of email objects), or if it has side effects like marking emails as read. For a tool with no annotations, this leaves significant 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?

The description is a single, efficient sentence with zero wasted words. It's front-loaded with the core purpose and appropriately sized for a simple retrieval 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?

Given the lack of annotations and output schema, the description is incomplete. It doesn't explain what 'gets' entails (e.g., returns email metadata, bodies, or just IDs), how results are ordered, or error conditions. For a search/retrieval tool in a complex email system with many siblings, more context is needed to guide effective use.

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

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

Schema description coverage is 100%, with both parameters ('mailbox' and 'limit') well-documented in the schema. The description doesn't add any parameter-specific information beyond implying it retrieves emails. This meets the baseline for high schema coverage, where the schema does the heavy lifting.

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

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

The description clearly states the verb ('Get') and resource ('all unread emails'), making the purpose immediately understandable. It doesn't explicitly differentiate from sibling tools like 'search_emails' or 'get_unread_count', but the focus on 'unread' emails provides some implicit distinction.

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

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

No guidance is provided about when to use this tool versus alternatives like 'search_emails' (which might support filtering by read status) or 'get_unread_count' (which returns only counts). The description doesn't mention prerequisites, exclusions, or comparative context with sibling tools.

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

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

With no annotations, the description carries full burden but only states the action without disclosing behavioral traits. It doesn't clarify if this is a read-only operation, if it changes server state, what happens on success/failure, or any side effects like caching. This is inadequate for a tool that likely interacts with mailbox state.

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

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

The description is a single, efficient sentence with zero waste—'Select/open a mailbox folder' is front-loaded and to the point. Every word earns its place, making it easy to parse quickly.

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

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

Given the complexity of mailbox operations and lack of annotations or output schema, the description is incomplete. It doesn't explain what the tool returns, how it affects subsequent calls, or error conditions. For a tool with one parameter but potential state changes, more context is needed to guide proper usage.

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

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

The input schema has 100% description coverage, with the parameter 'mailbox' documented as 'Mailbox name (e.g., INBOX, Sent)'. The description adds no additional meaning beyond this, such as format constraints or examples not in the schema. Baseline 3 is appropriate since the schema does the heavy lifting.

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

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

The description 'Select/open a mailbox folder' states a clear action (select/open) and resource (mailbox folder), but it's vague about what 'select/open' entails operationally—does it set a context, load emails, or change state? It doesn't distinguish from siblings like 'list_mailboxes' or 'get_mailbox_status', which might overlap in functionality.

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

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

No guidance is provided on when to use this tool versus alternatives. For example, it doesn't specify if this should be called before fetching emails or if it's needed for other operations, nor does it mention prerequisites like authentication. This leaves the agent guessing about its role among many sibling tools.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions 'permanent' and 'IDLE watch', hinting at a long-running or continuous operation, but fails to detail critical aspects such as what 'IDLE' entails, how the watch interacts with the system, potential side effects, or any performance implications like resource usage or 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?

The description is a single, compact sentence that directly states the tool's action and target without fluff. It's front-loaded with the key verb 'Start', making it easy to parse, though it could be slightly clearer by elaborating on 'IDLE watch' to improve 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?

Given the complexity implied by terms like 'permanent IDLE watch' and the lack of annotations and output schema, the description is insufficient. It doesn't explain what the watch does, how it behaves, what it monitors, or what outputs or states result from its use, leaving significant gaps in understanding for effective tool invocation.

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

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

The tool has 0 parameters, and the schema description coverage is 100%, so no parameter information is needed. The description appropriately avoids discussing parameters, making it efficient and focused on the tool's purpose without unnecessary details.

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

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

The description states the action ('Start permanent IDLE watch') and target ('on INBOX, next, waiting, someday'), which clarifies what the tool does. However, it's somewhat vague about the exact nature of an 'IDLE watch' and doesn't explicitly distinguish this tool from its sibling 'idle_watch' or 'stop_watch', leaving room for confusion about their differences.

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 provided on when to use this tool versus alternatives like 'idle_watch' or 'stop_watch'. The description implies it's for initiating a watch, but it doesn't specify prerequisites (e.g., whether authentication or connection is needed first) or contextual constraints, offering minimal 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 full burden. It states the tool stops a watch, implying a mutation/control action, but doesn't disclose behavioral traits like whether this requires specific permissions, if it's reversible, what side effects occur (e.g., does it terminate background processes?), or error conditions. The term 'permanent' hints at irreversibility but isn't elaborated.

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

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

The description is a single, efficient sentence with no wasted words. It's front-loaded with the core action ('Stop'), making it immediately clear. Every part of the sentence contributes to understanding the tool's function.

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 no parameters, no annotations, and no output schema, the description is incomplete. It doesn't explain what 'IDLE watch' is, what system it operates on, what happens after stopping (e.g., does it return status?), or error handling. For a control tool with zero structured context, more detail is needed to be fully helpful.

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 0 parameters, and schema description coverage is 100%, so no parameter documentation is needed. The description doesn't add parameter semantics, but that's acceptable here. Baseline is 4 for zero parameters, as there's nothing 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 'Stop the permanent IDLE watch' states a clear action (stop) but is vague about what 'permanent IDLE watch' refers to. It distinguishes from sibling 'start_watch' and 'idle_watch' by indicating a stopping action, but doesn't specify what resource or system this watch belongs to, leaving the purpose somewhat ambiguous.

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 on when to use this tool versus alternatives is provided. The description implies it should be used to stop a watch, but doesn't specify prerequisites (e.g., must have an active watch), when not to use it, or what happens if invoked without a running watch. It mentions 'permanent' but doesn't clarify if this is a one-time stop or if it affects future sessions.

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 burden for behavioral disclosure. While 'Remove flag' implies a mutation operation, it doesn't specify permissions required, whether the operation is reversible, what happens if flags don't exist, or any rate limits. For a tool that modifies email state, this 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?

The description is maximally concise - a single four-word phrase that communicates the core functionality without any wasted words. It's appropriately sized for this straightforward operation and gets directly to the point.

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

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

For a mutation tool with no annotations and no output schema, the description is insufficient. It doesn't explain what happens after flag removal, whether there are side effects, what permissions are needed, or how to verify success. The context demands more complete behavioral information than 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 100%, providing complete parameter documentation. The description adds no additional parameter semantics beyond what's in the schema. The baseline score of 3 reflects adequate but minimal value addition from the description regarding 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 action ('Remove flag') and target resource ('from emails'), making the tool's purpose immediately understandable. However, it doesn't differentiate from its sibling 'flag_email' beyond the opposite action, missing an opportunity to clarify the relationship between these complementary operations.

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. It doesn't mention prerequisites (like needing flagged emails), exclusions, or relationships with sibling tools like 'flag_email', 'search_flagged', or 'mark_read/unread' that might be relevant in email management workflows.

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