Skip to main content
Glama
agentisend

agentisend

Send many emails in one call

send_batch

Send up to 500 distinct emails in one API call and get ordered per-message results, so one bad address does not fail the batch. Use an idempotency key to prevent duplicate sends on retries.

Instructions

Purpose: send up to 500 different messages in one call, the same ceiling as POST /emails/batch. Each item takes the same fields as send_email, including headers and attachments. NOT for: one message to many recipients — that is send_email with a list of addresses. Each To, CC and BCC recipient counts as one email. Returns: sent, failed, and one result per item IN THE ORDER YOU SENT THEM, each carrying the same code and fix a single send would have given. One bad address does not fail the batch. Each accepted item costs its own recipient count, and each To, CC and BCC recipient counts as one email. Pass an idempotency_key: a retried batch without one sends every accepted item again.

Tool call template

Replace each placeholder with a value matching the input schema. Only required parameters are included; add optional parameters as needed.

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "arguments": {
      "emails": "<emails>"
    },
    "name": "send_batch"
  }
}

Input Schema

NameRequiredDescriptionDefault
emailsYesThe emails to send (max 500 per call, the same ceiling as POST /emails/batch).
idempotency_keyNoYour own key for this action. Retrying with the same key returns the first result instead of doing it twice — send one whenever a retry could double the effect.

Output Schema

NameRequiredDescriptionDefault
sentNo
errorNoPresent instead of the fields above when the call was refused: code, message, fix, docs_url, retryable and, when waiting helps, retry_after_seconds.
failedNo
resultsNoOne result per item, in the order sent.

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observedv0.1.0

TDQS

A4.4/5.0
Behavior3/5

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

Goes well beyond the annotations by disclosing partial-failure semantics ('One bad address does not fail the batch'), result ordering, per-recipient billing, and retry behavior without a key — all consistent with destructiveHint=false and idempotentHint=false, since it explicitly frames idempotency as opt-in via key rather than inherent. However, it never states what a 'fix' or error code per item looks like in practice, and it does not address rate limits or whether the batch is atomic under any condition, so the disclosure, while useful, is not complete.

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

Conciseness4/5

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

Front-loaded with explicit 'Purpose / NOT for / Returns' structure, which is easy to scan. The only waste is the duplicated clause 'each To, CC and BCC recipient counts as one email', which appears twice in near-identical form and could be stated once.

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

Completeness5/5

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

An output schema exists, so return values need not be described, yet the description still adds the ordering guarantee and one-result-per-item contract that matter for interpreting a batch response. Combined with failure isolation, billing, and idempotency guidance, an agent has everything needed to call this correctly and safely.

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

Parameters4/5

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

Schema coverage is 100%, so the baseline is 3, but the description adds real meaning on top: the nested items 'take the same fields as send_email, including headers and attachments', which tells the agent about item shape without enumerating properties, and the idempotency_key guidance explains the retry contract rather than just the type. The recipient-counting rule (To, CC, BCC each count as one email) also contextualizes how the max-500 ceiling is consumed.

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

Purpose5/5

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

Opens with a specific verb and resource plus a hard scope boundary ('send up to 500 different messages in one call'), then explicitly separates itself from the closest sibling: 'NOT for: one message to many recipients — that is send_email with a list of addresses.' An agent can pick between send_batch and send_email without reading either schema.

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

Usage Guidelines5/5

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

Gives both the when ('many different messages') and the when-not ('one message to many recipients'), names the alternative tool by name, and adds a operational precondition: pass an idempotency_key or a retry re-sends every accepted item. Nothing about selection is left to inference.

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