Strands Agents Email Integration

Why This Pairing Works

Strands Agents is AWS's open-source, model-driven agent SDK — 1.0 shipped in July 2025, and it's the framework behind Kiro and Amazon Q Developer. It takes a deliberately minimal view of tools: a @tool decorator that reads your docstring and type hints, and a built-in MCP client for everything else. Both map cleanly onto Dead Simple. One honesty note: Dead Simple ships native adapters for LangChain, CrewAI, AutoGen, LlamaIndex, and the OpenAI Agents SDK; for Strands, the supported paths are the two below — a hand-written @tool wrapper around our Python SDK, or the hosted MCP server.

Custom Tools with @tool

Strands turns any decorated function into a tool spec. Wrap the SDK calls your agent needs:

import os
from strands import Agent, tool
from deadsimple import DeadSimple

client = DeadSimple(os.environ["DSE_API_KEY"])

@tool
def send_email(inbox_id: str, to: str, subject: str, body: str) -> str:
    """Send a plain-text email from a Dead Simple inbox.

    Args:
        inbox_id: The inbox to send from, e.g. inb_a1b2c3.
        to: Recipient email address.
        subject: Subject line.
        body: Plain-text message body.
    """
    result = client.messages.send(inbox_id, to=[to], subject=subject, text_body=body)
    return f"Sent {result.message_id}"

@tool
def read_messages(inbox_id: str, limit: int = 5) -> list[dict]:
    """List the most recent messages in a Dead Simple inbox.

    Args:
        inbox_id: The inbox to read.
        limit: Maximum number of messages to return.
    """
    result = client.messages.list(inbox_id, limit=limit)
    return [
        {"from": m.from_email, "subject": m.subject, "snippet": m.snippet}
        for m in result.messages
    ]

agent = Agent(tools=[send_email, read_messages])
agent("Check inbox inb_a1b2c3 and reply-worthy messages, then draft "
      "a summary email to team@example.com.")

Strands defaults to Amazon Bedrock as the model provider, so this drops straight into existing AWS stacks — but the tools are provider-agnostic.

All 14 Tools via the Built-in MCPClient

Strands has native MCP support. Connect to Dead Simple's hosted server over streamable HTTP and list the tools straight into an agent — note that the agent must be used inside the client's context manager:

import os
from mcp.client.streamable_http import streamablehttp_client
from strands import Agent
from strands.tools.mcp import MCPClient

deadsimple = MCPClient(lambda: streamablehttp_client(
    "https://api.deadsimple.email/mcp",
    headers={"Authorization": f"Bearer {os.environ['DSE_API_KEY']}"},
))

with deadsimple:
    tools = deadsimple.list_tools_sync()
    agent = Agent(tools=tools)
    agent(
        "Create an inbox called 'signups', register for the beta at "
        "example.com with it, then wait for the verification email "
        "and read me the code."
    )

The server exposes create_inbox, list_inboxes, delete_inbox, send_email, read_messages, read_message, reply_to_message, forward_message, wait_for_email, get_verification_code, get_verification_link, list_threads, read_thread, and get_usage. Prefer stdio? pip install "deadsimple-email[mcp]" and swap the transport for stdio_client with command python, args ["-m", "deadsimple.mcp"], and DSE_API_KEY in the env.

Why Dead Simple Fits Strands

• Model-driven agents need complete loops. Strands lets the model plan; wait_for_email and get_verification_code mean email round-trips (signup, confirm, reply) close without human glue.
• AWS-native stack, email included. Your agent runs on Bedrock and Lambda; Dead Simple handles the one thing AWS doesn't hand you — real agent-owned mailboxes with deliverability managed.
• Two honest paths. Hand-picked @tool wrappers for production control, or the MCP client for the full toolset in five lines.
• Free plan is enough to build. Five inboxes and 5,000 emails/month, no card required.

FAQ

Related Integrations

• Claude Agent SDK — Anthropic's agent SDK with the same MCP connection
• Pydantic AI — the same pattern in the Pydantic team's framework
• Agno — custom email toolkit in a high-performance Python framework
• LangChain — native Dead Simple toolkit (shipped adapter)
• MCP Server — the server behind the MCPClient option
• Python SDK — the client these tools wrap