Meta Muse Integration

Two Ways In, Zero Code

Muse is Meta's personal AI agent, launched September 8, 2026. It runs on its own cloud computer (Meta calls it the Muse Secure VM), keeps working after you close the app, and connects to the services you use through connectors. A separate Sentinel process on the same machine approves every network request Muse makes, and Muse never sees the real credentials you give it. There is a free tier and paid tiers at $20 and $100 a month; the rollout is US-only and 18+ at launch.

What Muse does not ship with is an email address of its own. Meta's built-in email connector reads your Gmail, but it deliberately strips out one-time codes, password reset links and login magic links before Muse sees them, so Muse cannot finish a signup through your personal inbox. Dead Simple fixes that in two ways:

• Option A, the Muse app: a custom connector. Muse can build its own connector to any service with a public API. You hand it a key and a link to our connector brief, and it does the rest.
• Option B, Muse Code: remote MCP. Meta's terminal coding agent speaks Model Context Protocol. One block in settings.json gives it all seventeen Dead Simple tools.

Either way the agent gets a real mailbox it owns, with verification codes delivered unfiltered, and your personal address stays out of everything it sends.

Option A: A Custom Connector in the Muse App

Five steps, about five minutes, and the only thing you type by hand is one API key.

Step 1: Create an API key named "Muse"

Sign up free at app.deadsimple.email, then go to Settings → API Keys and create a key. Name it Muse. That name is what lets you revoke this one key later without touching anything else that uses your account. Copy the key; you will paste it exactly once.

Step 2: Ask Muse to build the connector

Muse writes its own connectors when a service has a public API. To make sure it builds the right thing first time, point it at the connector brief we publish for exactly this purpose. Paste this into the Muse chat:

Build a custom connector for Dead Simple Email so you have your own
email address. The connector brief is at
https://deadsimple.email/connectors/muse.md. Read it first.
Base URL is https://api.deadsimple.email and every request needs
"Authorization: Bearer" with the DSE_API_KEY secret I'm about to give
you. When the connector works, create one inbox for yourself called
"muse" and tell me the address.

The brief at deadsimple.email/connectors/muse.md is a plain markdown file: base URL, auth header, the eight calls a connector needs with request and response shapes, three recipes, and a short list of rules (one inbox per purpose, never delete unless asked, stop on a plan-limit error). It is written for the agent, not for you, but it is short enough to skim.

Step 3: Paste the key into the Secure Credentials Store

Muse will ask for the key and open its secrets panel (Meta calls it the Secure Credentials Store). Paste the key there and give it the name DSE_API_KEY. Do not paste the key into the chat. The whole point of Meta's design is that Muse only ever handles a surrogate token; Sentinel swaps in the real key at the network edge, so a prompt injection cannot make Muse leak it.

Step 4: Approve the connection

Sentinel will ask you to approve Muse talking to api.deadsimple.email. Approve it, and when it offers a scope, choose the standing (perpetual) option for this destination so you are not clicking through every send. Muse's own "ask before sending an email" check stays in place regardless; you can relax that in Muse's settings once you trust the setup.

Step 5: Prove it works

Send an email from your Dead Simple address to me at you@example.com
with the subject "hello from Muse".

# Reply to that email from your own inbox, then:

Did I reply? What did I say?

Under the hood the connector makes two calls for the first prompt and one for the second. This is what Muse is running for you:

# Create the inbox (once)
POST https://api.deadsimple.email/v1/inboxes
{"display_name": "Muse", "local_part": "muse"}
# → {"inbox_id": "…", "email": "muse_ab12@box1.deadsimple.email", …}

# Send
POST /v1/inboxes/{inbox_id}/messages
{"to": ["you@example.com"], "subject": "hello from Muse",
 "text_body": "It works."}

# Check for your reply (bodies come back in-thread)
GET /v1/inboxes/{inbox_id}/threads/{thread_id}

Want a specific address? Say so: "Create an inbox called car-sale with the display name Brooke." On the shared domain a short suffix is appended to the name you pick, so nobody can squat on role accounts. Bring a custom domain and the address is exactly what you ask for.

What Muse Can Do Once It Has an Address

• Sign up for things and finish the job. "Sign up for a trial of that tool using your own address." Muse fills the form, polls /verification until the code arrives, and enters it. Through Gmail this step fails because Meta filters the code out.
• Deal with third parties without exposing you. Quote requests to movers, a booking request to a restaurant, a follow-up on a refund. The reply lands in Muse's inbox, not yours, and Muse answers in-thread.
• Take forwarded mail. Give the address to people (or to yourself). Anything forwarded or CC'd to it is readable by Muse within seconds, with no Gmail connection at all.
• Sit on a thread. CC Muse's address on an ongoing conversation and ask it to summarise, chase, or draft the next reply.
• Watch for alerts. Point price-drop, restock and shipping notifications at the Muse address and ask it to tell you only about the ones that matter.
• Keep a human in the loop. Set require_draft_approval on the inbox and Muse's outgoing mail waits in the dashboard for your click. That is enforced on our server, not by asking the agent nicely.

Guardrails That Live Outside the Agent

Muse asks before sending email by default, and Sentinel gates every network call. Those are good controls, but they live inside Meta's stack. Dead Simple adds a second layer on the inbox itself, so the limits hold even if the agent is confidently wrong:

curl -X PUT https://api.deadsimple.email/v1/inboxes/{inbox_id}/guardrails \
  -H "Authorization: Bearer dse_your_api_key" \
  -d '{"max_sends_per_hour": 20,
       "allowed_domains": ["example.com", "yourbank.com"],
       "require_draft_approval": true}'

Set it once from the dashboard or with one call, and Muse cannot exceed it no matter what it is asked. Revoke the "Muse" key and the connector is dead in one click.

Option B: Muse Code via Remote MCP

Muse Code is Meta's terminal coding agent. It reads MCP servers from the mcp_servers block of its settings file at ~/.config/muse/settings.json, and supports the streamable_http transport with custom headers, which is all Dead Simple's remote server needs:

{
  "schema_version": 1,
  "mcp_servers": {
    "deadsimple": {
      "transport": "streamable_http",
      "url": "https://api.deadsimple.email/mcp",
      "headers": { "Authorization": "Bearer dse_your_api_key" },
      "mode": "optional"
    }
  }
}

mode: "optional" lets Muse Code start with a warning if the server is unreachable instead of refusing to launch. Meta's docs note that MCP tools run outside Muse Code's filesystem and network sandbox; because this is a remote server, there is no local process at all, only HTTPS to one host. Restart Muse Code and the tools appear:

Building on Muse Spark through the Meta Model API instead? That is ordinary function calling. Use the Python SDK or TypeScript SDK and wire the same calls in as tools.

Example Prompts

Once connected, try these with Muse:

• "Get quotes from three movers for a two-bedroom move on October 4th, from your own address. Tell me when all three have replied." One inbox, three sends, then Muse watches the threads.
• "Sign up for the free tier of that analytics tool with your address and finish the email verification." Create, submit, poll /verification, enter the code.
• "I've forwarded you the lease. Summarise the parts that mention early termination." The PDF's text is extracted server-side, so Muse reads it straight from the message.
• "Draft a reply to the landlord but don't send it until I've approved it." With require_draft_approval on, that is the only way mail can leave anyway.
• "Every morning, check your inbox for shipping updates and tell me anything that's delayed." Muse schedules it; the inbox is the source of truth.
• "How many emails have you sent this month?" The usage endpoint answers with the plan limits alongside.

Why Dead Simple Is a Good Fit for Muse

• Codes arrive unfiltered. Meta strips OTPs and magic links from the Gmail connector on purpose. A Dead Simple inbox is the agent's own, so the /verification endpoint hands the code straight back.
• Your name stays off the agent's mail. Nothing Muse sends goes out from your personal account or your personal sender reputation.
• No account to get suspended. Every agent platform that ran through Gmail has hit disabled accounts sooner or later. There is no Google login here to trip.
• A brief the agent can actually follow. Muse builds the connector itself, and the published brief means it builds the right eight calls instead of guessing from a 100-endpoint spec.
• Server-side guardrails. Send caps, domain allow-lists and draft approval are enforced by the inbox, not by the agent's judgement.
• Free plan is enough. Five inboxes and 5,000 emails a month, no card, which is more than a personal Muse will use.

Full Walkthrough

For the long version, with troubleshooting and a closer look at what Meta's connector model does and does not allow, read the blog post:

How to Give Meta Muse Its Own Email Address

FAQ

Related Integrations

• Connector brief: the markdown file Muse reads to build the connector
• MCP Server: the remote server Muse Code connects to
• Grok & Grok Bot: the same pattern for xAI's personal agent
• OpenClaw: same MCP server, different assistant
• Hermes Agent: MCP plus an inbox as the agent's email channel
• Python SDK: for Muse Spark function-calling on the Meta Model API