google adk email integration: giving your agent a real inbox

Google's Agent Development Kit shipped its integrations ecosystem in early 2026, and email was one of the first categories to fill up. Gmail MCP adapters, Composio toolkits, ApplicationIntegrationToolset, Mailgun connectors. Lots of options. The problem is that most of them give your agent access to your inbox, not its own. That distinction matters more than it sounds.

I spent a week wiring email into ADK agents using four different approaches. Here's what I learned, what broke, and what actually worked in production.

What is Google ADK?#

Google's Agent Development Kit is an open-source Python framework for building AI agents. You define an LlmAgent with a system prompt, attach tools, and the framework handles orchestration, memory, and multi-agent coordination. It supports Gemini, GPT-4, Claude, and other models through a unified interface.

The interesting part for email is ADK's tool system. Tools can be Python functions, OpenAPI specs, or MCP servers. That last one is what makes email integration straightforward: if an email service exposes an MCP server, your ADK agent can use it with a few lines of configuration.

How to integrate email with Google ADK#

Here's the high-level process, regardless of which email provider you pick:

1. Install the ADK SDK (pip install google-adk)
2. Choose an email toolset: Gmail MCP, Composio, ApplicationIntegrationToolset, or an agent-native provider
3. Configure authentication (OAuth for Gmail, API keys for everything else)
4. Register the toolset with your LlmAgent
5. Define email actions in your agent's system prompt (send, read, reply)
6. Test locally with adk web before deploying
7. Add monitoring, retry logic, and rate-limit handling for production

Each toolset has tradeoffs. Let me walk through the main options.

Option 1: Gmail via MCP (Composio)#

Composio wraps Gmail's API behind an MCP server. The setup looks like this:

from google.adk.agents import LlmAgent
from google.adk.tools.mcp_tool import MCPToolset, StdioServerParameters

gmail_tools = MCPToolset(
    connection_params=StdioServerParameters(
        command="npx",
        args=["-y", "@composio/mcp@latest", "start",
              "--tools", "GMAIL_SEND_EMAIL,GMAIL_FETCH_EMAILS"],
        env={"COMPOSIO_API_KEY": "your-key-here"},
    )
)

agent = LlmAgent(
    model="gemini-2.5-pro",
    name="email_agent",
    tools=[gmail_tools],
    instruction="You can send and read emails using Gmail.",
)

This works. Your agent can read your Gmail, send from your address, and search threads. The catch: it's your Gmail. Every email the agent sends comes from your personal or workspace account. Every email it reads is your actual mail.

For a personal assistant agent, that might be fine. For an autonomous agent that handles customer communication, signs up for services, or operates independently? You probably don't want it sharing your inbox.

There's also the OAuth dance. Someone has to complete the consent screen, and that someone is a human. If you're building agents that provision themselves, this is a blocker.

Option 2: ApplicationIntegrationToolset (Google Cloud)#

Google's own offering uses Application Integration, a Cloud service that connects to Gmail, Outlook, and other apps. The setup requires a Google Cloud project, a service account, and an integration workflow.

from google.adk.tools.application_integration_tool import ApplicationIntegrationToolset

email_tool = ApplicationIntegrationToolset(
    project="my-gcp-project",
    location="us-central1",
    connection="gmail-connection",
    actions=["send_email", "list_messages"],
)

This approach is more production-ready than the Composio MCP route. You get audit logs, IAM controls, and enterprise support. But you're still sending from a delegated human mailbox, and the setup involves Cloud console configuration that an agent can't do on its own.

Option 3: agent-native email#

The first two options share a fundamental assumption: the agent borrows a human's email. Agent-native email flips that. The agent gets its own address, its own inbox, its own sending reputation.

With LobsterMail, the ADK integration uses our MCP server:

from google.adk.tools.mcp_tool import MCPToolset, StdioServerParameters

lobster_tools = MCPToolset(
    connection_params=StdioServerParameters(
        command="npx",
        args=["-y", "@anthropic-ai/mcp-lobstermail@latest"],
    )
)

agent = LlmAgent(
    model="gemini-2.5-pro",
    name="outreach_agent",
    tools=[lobster_tools],
    instruction="Create your own email inbox and use it to send messages.",
)

No OAuth. No human in the loop. The agent provisions an address like outreach-agent@lobstermail.ai and starts sending. Each agent gets its own identity, its own inbox, and built-in protection against prompt injection in incoming emails.

The tradeoff is that your agent isn't sending from you@yourcompany.com. For agents that need to represent you personally, Gmail integration makes more sense. For agents that operate as their own entity, agent-native email removes the dependency on human accounts entirely.

Comparing the three approaches#

Production checklist for ADK email agents#

Before shipping an ADK agent that sends email, check these:

Rate limits. Gmail's API allows 100 messages per second per user, but daily sending limits are lower (2,000 for Workspace, 500 for free Gmail). Your agent needs backoff logic, or it will hit 429 errors and lose messages silently.

Bounce handling. What happens when your agent sends to a bad address? Gmail surfaces bounces as inbox messages. Agent-native providers return bounce data through the API. Either way, your agent needs logic to detect and stop sending to dead addresses.

Unsubscribe compliance. If your agent sends anything resembling marketing email, CAN-SPAM and GDPR require a working unsubscribe mechanism. This isn't optional, and "my agent did it" is not a legal defense.

Thread management. Email conversations have thread IDs. If your agent replies to a message, it needs to set the correct In-Reply-To and References headers, or the reply will start a new thread in the recipient's inbox. Most MCP wrappers handle this. Verify yours does.

Logging. Every email your agent sends should be logged somewhere you can audit. Autonomous agents that send email without an audit trail are a liability.

When to use which approach#

Use Gmail MCP when your agent is a personal assistant that reads and drafts emails on behalf of a specific human. The human is in the loop, the agent uses their account, and the setup is a one-time OAuth flow.

Use ApplicationIntegrationToolset when you're in a Google Cloud environment with existing IAM policies and need enterprise-grade access controls. The setup cost is high, but the governance is real.

Use agent-native email when your agent needs its own identity, provisions itself without human intervention, or operates at scale across multiple instances. If you're building something where each agent (or each customer's agent) needs a distinct email address, sharing a single Gmail doesn't scale.

If you want to try the agent-native approach, grab an inbox for your ADK agent here. Your agent handles the setup itself.