How to Give Grok Bot Its Own Email Inbox

On August 11, 2026, xAI launched Grok Bot in beta: always-on AI agents that run on their own cloud computers, sign into your tools, and finish multi-step jobs without supervision. One thing a Grok Bot does not get at birth is an email address. It can borrow yours through an OAuth grant, but it cannot send or receive mail on an address it actually owns. This guide fixes that two ways: a one-command MCP setup for Grok Bot itself, and a working grok-4.6 function-calling loop for anyone building a Grok agent directly on the xAI API. Both paths end with an agent that has a real inbox, its own address, and webhook-driven receive.

The short version: Dead Simple Email hosts an MCP server at https://api.deadsimple.email/mcp. Point Grok Bot at it with grok mcp add and the agent picks up 14 email tools. On the API side, the same capabilities drop into the tools array of a Responses API call. Total setup time for either path is about three minutes.

What Grok Bot Is (and What It's Missing)

Grok Bot is xAI's agent product, distinct from Grok the assistant and from the model family you call through the API. Each bot gets a persistent cloud computer, a plugin browser, and the ability to work unsupervised on long-horizon tasks. It shipped in beta on August 11, 2026, bundled with SuperGrok Heavy, Cursor Ultra ($200/mo), and Cursor Teams Premium ($120/seat/mo). One day later, xAI released grok-4.6, the flagship API model positioned specifically for long-running agents, with a 500k-token context window at $2.00 per million input tokens and $6.00 per million output tokens.

Here's the gap. The xAI Agent Tools API gives Grok server-side tools for web search, X search, code execution, image generation, and collections search. Email is not on that list. There is no built-in way for a Grok agent to send a message, own an address, or react to an inbound reply. Grok Bot's plugin system can OAuth into a human's Gmail or Outlook, which is useful for "summarize my inbox" but is the wrong shape for an autonomous teammate, for reasons we'll get to. If you want a Grok agent that has email rather than borrows email, you need to bring the inbox yourself.

That's exactly the workload Dead Simple Email was built for: agent-owned inboxes behind one clean API, with sending, receiving, threading, and webhooks handled. We've written before about why agents need email at all and why agent identity has to include an address. This post is the Grok-specific how-to.

Why Your Gmail Is the Wrong Inbox for Grok Bot

The OAuth path is tempting because it's one click. It's a bad foundation for three reasons.

First, suspension risk. Google actively suspends accounts it flags as agent-controlled; programmatic sending from a consumer account violates the terms of service, and the detection heuristics have gotten aggressive. We've documented the pattern in Gmail is suspending AI agent accounts. An always-on agent hammering the Gmail API from a cloud computer is precisely the traffic profile that gets flagged, and when the account goes down, it's your account.

Second, identity. A Grok Bot that emails a customer from you@gmail.com is impersonating you. Replies land in your personal inbox, mixed with your own mail. You can't hand the bot a scoped identity, can't rotate its credentials independently, and can't shut it off without touching your own account.

Third, operational blast radius. Autonomous agents make mistakes. When an agent with its own inbox misfires, you delete the inbox. When an agent with your OAuth grant misfires, you're auditing your own sent folder.

A dedicated inbox costs nothing to try (Dead Simple's free tier includes 5 inboxes and 5,000 emails a month) and gives the agent a real address like grokbot@yourco.com on a custom domain, with SPF, DKIM, and DMARC already configured. Here's how to wire it up.

Path 1: Add Email to Grok Bot with One MCP Command

Grok Bot supports remote MCP servers through the Grok Build CLI. Dead Simple's MCP server is hosted, so there's nothing to install or run: you register the URL, pass your API key as a header, and the tools appear.

Step 1: Get a Dead Simple API key

Sign up free (no card required), then create a key under Settings → API Keys. Keys are prefixed dse_.

Step 2: Register the MCP server

# Grok Build CLI — registers the hosted MCP server with Grok Bot
grok mcp add deadsimple https://api.deadsimple.email/mcp \
  --transport http \
  --header "Authorization: Bearer dse_your_api_key_here"

# Verify the 14 email tools registered
grok mcp list

The server speaks Streamable HTTP, authenticates per-request from the Authorization header, and holds no session state, so it works the same from Grok Bot's cloud computer as it does from Claude Desktop or Cursor. If you'd rather run it locally, pip install "deadsimple[mcp]" and launch python -m deadsimple.mcp with DSE_API_KEY set; the tool surface is identical.

Step 3: Prompt the bot

Create an inbox called "GrokBot Ops" and tell me its address.
Then email hello@example.com introducing yourself and asking
them to reply with this week's priorities. When the reply
arrives, summarize it for me.

Grok Bot calls create_inbox, reports the new address, sends with send_email, and then either polls with wait_for_email or picks the reply up on its next tick via read_messages. No plugin marketplace, no OAuth consent screen, no scopes to review. One command and a prompt.

The 14 Email Tools Grok Gets

Registering the server exposes these tools. Each returns compact JSON the model can act on directly.

The verification tools deserve a callout for Grok Bot specifically. An always-on agent signing itself into services keeps hitting email verification walls; get_verification_code and get_verification_link turn "check your email to continue" into a single tool call. We cover that pattern in depth in how AI agents receive verification codes and OTPs.

Path 2: Function Calling with the Grok API

If you're building your own agent on the xAI API rather than using Grok Bot, wire the same inbox in with function calling. Two things changed in 2026 that most tutorials haven't caught up with: the Responses API (POST /v1/responses) is now the primary endpoint, with Chat Completions marked legacy, and the old model IDs are gone. grok-4, grok-4-fast, and the grok-3 family were retired; requests to them silently redirect to grok-4.3. Use grok-4.6 for agent workloads.

The xAI API is OpenAI-compatible, so the standard openai Python package pointed at https://api.x.ai/v1 works. Here's a complete, runnable loop: four email tools declared to Grok, executed locally with the deadsimple SDK (pip install deadsimple-email openai).

import json, os
from openai import OpenAI
from deadsimple import DeadSimple

grok = OpenAI(api_key=os.environ["XAI_API_KEY"],
              base_url="https://api.x.ai/v1")
dse = DeadSimple(os.environ["DSE_API_KEY"])

TOOLS = [
    {"type": "function", "name": "create_inbox",
     "description": "Create an email inbox owned by this agent.",
     "parameters": {"type": "object", "properties": {
         "display_name": {"type": "string"}}}},
    {"type": "function", "name": "send_email",
     "description": "Send an email from an inbox.",
     "parameters": {"type": "object", "required": ["inbox_id", "to", "subject", "body"],
         "properties": {"inbox_id": {"type": "string"}, "to": {"type": "string"},
                        "subject": {"type": "string"}, "body": {"type": "string"}}}},
    {"type": "function", "name": "read_messages",
     "description": "List recent messages in an inbox.",
     "parameters": {"type": "object", "required": ["inbox_id"],
         "properties": {"inbox_id": {"type": "string"}}}},
    {"type": "function", "name": "reply_to_message",
     "description": "Reply to a message, preserving the thread.",
     "parameters": {"type": "object", "required": ["inbox_id", "message_id", "body"],
         "properties": {"inbox_id": {"type": "string"}, "message_id": {"type": "string"},
                        "body": {"type": "string"}}}},
]

def run_tool(name, args):
    if name == "create_inbox":
        inbox = dse.inboxes.create(display_name=args.get("display_name", "Grok Agent"))
        return {"inbox_id": inbox.inbox_id, "address": inbox.email_address}
    if name == "send_email":
        sent = dse.messages.send(args["inbox_id"], args["to"],
                                subject=args["subject"], text_body=args["body"])
        return {"message_id": sent.message_id, "status": "sent"}
    if name == "read_messages":
        msgs = dse.messages.list(args["inbox_id"], limit=10)
        return [{"id": m.message_id, "from": m.from_email,
                 "subject": m.subject} for m in msgs.messages]
    if name == "reply_to_message":
        sent = dse.messages.reply(args["inbox_id"], args["message_id"],
                                 text_body=args["body"])
        return {"message_id": sent.message_id, "status": "replied"}

response = grok.responses.create(
    model="grok-4.6", tools=TOOLS, tool_choice="auto",
    input="Create an inbox for yourself, then email hello@example.com "
          "a two-line introduction and tell me the address you sent it from.")

# Tool loop: execute every function call, feed results back, repeat
while any(item.type == "function_call" for item in response.output):
    outputs = []
    for item in response.output:
        if item.type == "function_call":
            result = run_tool(item.name, json.loads(item.arguments))
            outputs.append({"type": "function_call_output",
                            "call_id": item.call_id,
                            "output": json.dumps(result)})
    response = grok.responses.create(
        model="grok-4.6", tools=TOOLS,
        previous_response_id=response.id, input=outputs)

print(response.output_text)

A detail worth knowing: xAI charges per-invocation fees for its server-side tools ($5 per thousand web or X searches, $5 per thousand code executions), but custom client-side function calls like these carry no invocation fee at all. You pay tokens only. Your email tools are the cheapest tools your Grok agent has.

For receive-driven agents, skip polling: register a webhook with dse.webhooks.create(url, events=["message.received"]) and have your endpoint kick off a Grok run whenever mail arrives. That turns the agent from "checks email when asked" into "wakes up when email arrives," which is the shape a real teammate has.

What It Costs

An email-enabled Grok agent has exactly two line items:

A prototype (one inbox, a few hundred emails, short agent runs) fits entirely inside the free tier plus a few cents of grok-4.6 tokens. For the broader market context, including AgentMail's jump from $20/mo to $200/mo with nothing in between, see our 2026 email API cost comparison.

Grok Email Backend Options, Compared

The honest note: if your only need is "Grok, summarize the newsletter mail in my personal Gmail," the OAuth plugin is fine, and AgentMail's Grok Bot integration is real and works. The case for Dead Simple is a smoother price ramp ($0, $5, $29, $99 instead of a $20-to-$200 jump), a dashboard on every plan including Free, and inbound prompt-injection scanning on every message before your agent acts on it, which matters more, not less, when the agent runs unsupervised. How that inbound pipeline works under the hood is covered in email infrastructure for AI agents, explained.

Five Jobs for a Grok Bot with Its Own Inbox

1. Autonomous signups. Grok Bot signs up for a service on its cloud computer, hits the verification wall, and calls get_verification_code on its own inbox. No human in the loop.
2. A support address on autopilot. Point support@yourco.com at an inbox Grok owns. Webhooks wake the agent per message; it classifies, answers what it can, and forwards edge cases to a human with forward_message.
3. Long-horizon check-ins. A Grok Bot working a week-long research task emails you a nightly digest from its own address, and reads your reply the next morning as new instructions, in-thread.
4. Agent-to-agent coordination. Two bots with two addresses coordinate over plain email, with threading for free. Email is the one channel every agent framework already understands; we make the case in every agent needs an inbox.
5. Auditable outbound. Everything the bot sends lives in an inbox you can open in the dashboard, separate from any human's mail. When you want to know what your agent said to a customer, you read its sent folder, not yours.

Frequently Asked Questions

What is Grok Bot, and how is it different from Grok?

Grok is xAI's assistant and model family. Grok Bot is the always-on agent product launched in beta on August 11, 2026: each bot runs on its own cloud computer, signs into tools, and works unsupervised. It's bundled with SuperGrok Heavy, Cursor Ultra, and Cursor Teams Premium. The API model behind agentic workloads is grok-4.6, released August 12, 2026 with a 500k context window.

Can Grok Bot just use my existing Gmail account?

It can, via OAuth, but that gives an autonomous agent shared access to a human inbox rather than an identity of its own. Google suspends accounts it flags as agent-controlled, the bot's traffic mixes into your personal mail, and revoking the agent means touching your own account. A dedicated inbox sidesteps all three.

Does the xAI API have a built-in email tool?

No. The Agent Tools API ships web search, X search, code execution, image generation, and collections search. Email is absent from the list, which is why it has to come in through function calling or MCP.

Which Grok model should I use for an email agent?

grok-4.6. It's the flagship built for long-running agents. Note that grok-4, grok-4-fast, and the grok-3 family are retired; requests to those IDs silently redirect to grok-4.3, so any tutorial still using them predates May 2026.

Do the same email tools work outside Grok?

Yes. The MCP server at api.deadsimple.email/mcp is client-agnostic: the identical setup works in Claude Desktop, Cursor, Windsurf, Hermes Agent, and OpenClaw. The REST API and SDKs work with any framework, with drop-in helpers for LangChain, CrewAI, AutoGen, LlamaIndex, and the OpenAI Agents SDK on the integrations page.

The Bottom Line

Grok Bot is the most aggressive bet yet on agents as always-on teammates, and a teammate you can't email is a teammate with a reachability problem. xAI ships no email capability in the API, and the OAuth plugin path puts your own account on the line. The fix takes three minutes on either path: grok mcp add with Dead Simple's hosted MCP server for Grok Bot, or a grok-4.6 function-calling loop for API-built agents. Either way your agent ends up with an address it owns, threading that works, webhooks on receive, and deliverability someone else worries about.

Sign up free: five inboxes and 5,000 emails a month, no card, which is more than enough to register the MCP server, watch Grok create its own inbox, and see the first reply come back. The Grok integration page has the quick-start config, the MCP integration page has the full tool reference, and getting started covers the REST API from zero.