Agent Email List — Free SMTP Relay for AI Agents

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

With no annotations provided, the description carries the full burden. It discloses that the tool returns DNS records, that publishing them typically requires a human with registrar access, and that sending is blocked until verification succeeds. These are meaningful behavioral traits beyond the schema, though it does not mention idempotency or error behavior for duplicate calls.

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

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

Three sentences, each purposeful: the first states the core action and output, the second gives operational advice, and the third names the verification dependency. No filler or repetition.

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

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

For a one-parameter tool with no output schema and no annotations, the description explains the registration flow, DNS record output, and the verification prerequisite. It is complete enough for an agent to know what to expect and when to invoke it, though it does not describe the exact structure of the returned DNS records.

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

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

Schema coverage is 100%, so the parameter description already fully documents 'name' as a bare domain and recommends a subdomain. The tool description adds nothing about the parameter format or meaning beyond what the schema provides, so the baseline 3 applies.

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

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

The description uses a specific verb ('Register') and resource ('a domain to send from'), and clearly separates this from sibling tools by explaining it produces DNS records and is a prerequisite for verify_domain. An agent can immediately distinguish this from list_domains, verify_domain, or send_email.

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

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

The description gives practical timing guidance ('start this early'), notes the human-in-the-loop DNS requirement, and explicitly states the domain cannot send until verify_domain succeeds. This is clear context for when to use add_domain, though it does not explicitly contrast it with sibling tools beyond verify_domain.

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?

The description discloses important behavioral traits: the API key is returned only once and never again, and the service is free with no card or trial clock. These details go beyond the basic schema and help the agent understand the consequences of calling this tool. However, it doesn't mention what happens if the email already exists or other error conditions, which would be useful.

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: it states the core purpose first, then adds key behavioral details. Every sentence earns its place, and the structure is easy to parse. It's not overly verbose and covers the essential points.

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 (3 params, no output schema, no annotations), the description covers the essential context: what it does, when to use it, and key behavioral caveats. It could mention error handling or idempotency, but for a simple account creation tool, it's largely complete. The lack of an output schema is mitigated by the description stating that an API key is returned.

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 parameters. The description adds context about the password ('Needed only to sign in to the web console') and the email ('A contact address'), but these are already in the schema. The description doesn't add significant new meaning beyond the schema, so a baseline 3 is appropriate.

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

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

The description clearly states the tool's purpose: creating an account on the email service and receiving an API key. It uses a specific verb ('create') and resource ('account'), and it distinguishes itself from siblings by emphasizing that it requires no existing credentials, making it the entry point for agents with nothing.

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 explicitly states when to use this tool: 'Needs no existing credentials, so an agent with nothing can call this first.' This provides clear context and implies that other tools require credentials, effectively guiding the agent to use this tool as the first step. It doesn't explicitly name alternatives, but the context is strong enough.

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 usefully reveals a non-obvious behavior: send success is not delivery confirmation and delivery outcomes appear here. It also names some event states stub. However, it omits other behavioral context such as whether results are paginated, how far back history goes, or whether authorization is required, leaving gaps for a transparent read.

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

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

Two sentences with no fluff. The first sentence defines the tool's core purpose and event kinds, and the second adds a critical distinction about queued vs. delivered. Every part earns its place and the most valuable insight is front-loaded.

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

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

Although it is a read-style tool, the lack of an output schema and the unexplained 'limit' and 'recipient' parameters leave notable gaps. An agent knows what the tool does but not the shape of the response, the semantics of key parameters, or pagination behavior, so it cannot fully anticipate or validate a call.

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

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

Schema description coverage is only 25%, with only 'event' documented in the schema. The description partly compensates by mentioning domain scope ('on this domain') and examples of event values ('accepted, delivered, failed'), but it says nothing about the 'limit' or 'recipient' parametersebb. With most parameters undocumented and no description-level guidance, an agent cannot fully understand the filter options.

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 'What happened to messages on this domain' and enumerates event types (accepted, delivered, failed), giving a specific verb and resource. It also distinguishes itself from send_email by explaining that a successful send only means queued, not delivered, making its purpose clear and differentiating it from sibling 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 line 'A send returning success means queued, not delivered; this is where the delivery outcome actually appears' provides a clear context for when to use the tool: after sending, when you need to know the actual delivery result. It implies the tool is for checking outcomes rather than sending, but it does not explicitly contrast with list_messages or list_domains, so exclusion guidance is incomplete.

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 transparency burden. It discloses meaningful behavior: new domains start at a low daily cap and climb as they prove themselves, and it reveals whether sending is paused and how many domains the account may hold. It stops short of stating error behavior or caching, but for a read-only limits query it provides solid context.

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

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

Three sentences, all substantive: the first states output meaning, the second explains the dynamic cap behavior, and the third gives invocation guidance. No filler or repetition of schema names; information is front-loaded.

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

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

For a tool with one optional parameter and no output schema, the description explains the key return concepts: daily cap, graduation trigger, account standing, paused status, and the difference between domain-level and account-level calls. This is enough for an agent to select and invoke it correctly without additional 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 already documents 'domain' as optional with 100% coverage. The description adds practical nuance by clarifying that omitting the domain returns account-level limits while including it returns the domain's allowance. This goes slightly beyond the schema's wording, earning above baseline.

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

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

The description opens with a specific question the tool answers: how much a domain may send today, what raises its cap, and the account's standing (domain count, paused status). This clearly distinguishes it from siblings like send_email or get_delivery_events, which concern sending actions and delivery history rather than limits.

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

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

It provides explicit when-to-use guidance: 'check this before planning a bulk send rather than discovering it part-way.' It also explains the optional parameter behavior: omit domain for account-level answer. It lacks explicit when-not-to-use guidance or named alternatives, but the context is clear enough for a one-parameter read tool.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It clearly communicates a read-only listing behavior and specifies the returned information, which is useful, but it omits details like whether pagination, ordering, or only-verified-domains filtering apply. The description is adequate but not deeply transparent.

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

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

A single, front-loaded sentence that states the action, the object, scope, and key output fields without filler. Every phrase earns its place.

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

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

For a zero-parameter list tool with no output schema, the description is nearly complete: it names the main returned attributes (verification state and remaining allowance). It could be slightly richer about response format or relationship to other limit-related tools, but nothing essential is missing for a correct invocation.

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

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

The tool has zero parameters and 100% schema coverage, so the schema already fully documents the input contract. The description adds no parameter-specific meaning, but none is needed; the zero-parameter baseline of 4 applies here.

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

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

The description uses a specific verb ('List') with a clear resource ('sending domains') and scope ('on this account'), immediately distinguishing it from siblings like list_messages and get_sending_limits. It also specifies what is returned: verification state and remaining sending allowance, leaving no ambiguity about the tool's function.

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 when to use it: when the agent needs domain-level verification state or remaining allowance information. However, it offers no explicit when-not-to-use guidance or mention of alternatives such as get_sending_limits, which might be relevant if account-level limits are needed.

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 mentions 'recent messages' and filtering, but doesn't disclose behavior like pagination, ordering, whether spam is included by default, or what happens when folder is omitted. The description adds some context but leaves significant behavioral gaps.

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

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

The description is a single concise sentence that front-loads the core purpose and then adds filtering guidance. It earns its place without redundancy, though it could be slightly more 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?

For a list tool with 4 parameters and no output schema, the description covers the main filtering dimensions but omits important context like default folder behavior, ordering, pagination, and whether outbound messages have folders. It's adequate but not complete.

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

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

Schema description coverage is only 25% (only 'limit' has a description). The description adds meaning for 'direction' and 'folder' by explaining their purpose, which compensates partially. However, 'domain' remains undocumented in both schema and description, and the description doesn't clarify defaults or interactions between 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 states a clear verb ('list') and resource ('messages for a domain'), and distinguishes sent vs received via direction and inbox vs spam via folder. It doesn't explicitly name a sibling alternative, but the scope is specific enough to differentiate from siblings like get_delivery_events or send_email.

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

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

The description gives clear context on when to use the tool: for recent messages on a domain, with direction and folder as filters. It doesn't explicitly state when not to use it or name alternatives, but the filtering guidance is actionable and sufficient for basic 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, and it does so meaningfully: each recipient consumes one unit of the daily allowance, and test_mode runs the full pipeline including content screening without sending or spending allowance. This goes beyond the schema's field descriptions. It does not describe error handling or the response shape, but the core side effects and dry-run semantics are explicit.

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

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

The description is three short, front-loaded sentences: purpose first, then constraints and cost, then the test_mode workflow. There is no filler, no repetition of schema details, and no unnecessary complexity. Every sentence earns its place.

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

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

For a 7-parameter mutation tool with no annotations and no output schema, the description manages to cover prerequisites, quota impact, and a safe testing workflow. It does not describe the response payload or explicitly link to get_sending_limits or verify_domain, but an agent still has enough guidance to invoke the tool correctly and avoid unintended sends.

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

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

Schema coverage is 86%, so the schema already documents most parameter formats. The description adds the crucial invariant that the from address must belong to the verified domain, clarifies that the to field can imply multiple recipients and that allowance is counted per recipient, and gives test_mode operational meaning beyond simply 'send nothing.' This is valuable semantic information not present in the schema alone.

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

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

The description opens with the concrete action 'Send a message,' which clearly identifies the tool's purpose, and the surrounding domain/from constraints confirm it is about email sending. No sibling tool performs sending, so there is no risk of confusing it with another operation. The resource is stated only generically as 'message' rather than 'email,' but the tool name and schema remove that 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 gives clear operating preconditions: the domain must be verified and the from address must belong to it. It also prescribes a workflow by telling the agent to run test_mode true first when building. It does not explicitly compare against sibling tools, but none of the siblings are sending alternatives, so no alternative routing is needed.

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 transparently reveals that this is a network read operation that also mutates state ('mark the domain active') and that it's a polling operation subject to propagation delay. It doesn't cover the negative case (what happens when records aren't yet visible) or idempotency, but the core behavior is clearly exposed.

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

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

Two sentences, zero waste, with the core action front-loaded in the first sentence and the timing caveat delivered efficiently in the second. Every part earns its place.

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

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

The tool is simple (1 param, no output schema) and the description covers action, condition, and polling timing. However, gaps remain: the `name` parameter is never explicitly defined, and — critically for a propagation-dependent tool — the description doesn't state what happens when records aren't yet visible (failure, retry, or no-op), which an agent needs to handle the polling loop correctly.

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

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

Schema description coverage is 0% — the single required `name` parameter has no meaning in the schema. The description never explicitly defines `name` as the domain to verify; it only implies it through repeated references to 'the domain.' Since coverage is zero, the description must compensate by defining the parameter explicitly, and it does so only implicitly.

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

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

The description states a specific action — 'Re-read DNS now and mark the domain active' — tied to a clear condition ('if its SPF and DKIM records are visible'). The verb+resource is precise and clearly distinguishes this from siblings like add_domain (creation) and list_domains (listing), establishing verify_domain as the activation/verification step in the domain lifecycle.

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

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

The description gives practical timing guidance: 'DNS takes minutes to hours to propagate; poll this every few minutes, not every few seconds.' This tells the agent when and how often to invoke the tool during propagation. It doesn't explicitly name alternatives or state when not to use it, but the polling cadence is concrete and actionable.

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