Engineering
The Architecture
of Intelligence
Guides, product updates, and thoughts on AI, email protocols, and browser automation.
Set up Lumbox MCP in Claude Code and Cursor
Configure hosted HTTP or local stdio email tools, verify authentication, and retrieve a code without confusing MCP and REST parameters.
AgentMail vs Lumbox for customer portal agents
Compare AgentMail and Lumbox on inbox ownership, verification-code retrieval, entry pricing and the work needed for a portal-agent pilot.
Email for browser agents using Skyvern, Browserbase or Steel
Connect browser automation to an agent-owned inbox with an explicit handoff for verification codes and a testable login outcome.
All Posts
Build a support inbox agent that drafts every reply for approval
Point support@ on your domain at a Lumbox inbox, give the agent your help docs, and approve each reply it drafts before it goes out.
How AI agents receive email OTP codes
Give a browser workflow an inbox, retrieve a parsed verification code, and distinguish delivery failures from parsing and login failures.
Email Verification When You Are One Person
Verification vendors price for sales teams buying lists. If you are one person with a signup form and a side project, most of that cost buys you nothing. Here is what is worth paying for and what is not.
We Buy the Browser and Build the Inbox
Stealth browser runtimes have become a commodity with at least five credible vendors. Mailboxes that an agent can actually reason about have not. Here is how we decided which half of an agent runtime to build, and the test we used.
Pagination Is an Agent Experience Problem
An unpaginated list endpoint that a human tolerates will destroy an agent. Ours returned 794KB and blew the context window of the model calling it, on the API we sell to agents.
Plan Then Execute: One LLM Call Instead of Thirty
Most browser agents ask the model what to do next on every single step, which means re-deriving the same plan twenty times and paying for the page state each time. Here is the alternative, the exact ten step schema we run, and the arithmetic on why it costs two orders of magnitude less.
Sequential IDs Are a Security Decision
A lookup that accepts both a random public handle and an auto-increment id gives you an enumerable API even when every URL you generate is unguessable. The dangerous part is the helper that accepts either.
A Rate Limit Keyed on a Header the Caller Sets Is Not a Rate Limit
If your limiter buckets by X-Forwarded-For and your origin is reachable directly, the cap is a value the caller chooses. Which headers you can trust depends entirely on your deployment, not on the header name.
Your Health Check Is Lying to You
A /health endpoint that returns 200 without touching a dependency will stay green while every real request fails. Ours did, for five days. The fix is not to add a database ping.
Your Email Landed in Spam. Here Is the Order to Check Things.
Spam placement has maybe six real causes and people usually check them in the wrong order, starting with content and ending with authentication. Reverse it.
One-Click Unsubscribe: What Gmail and Yahoo Actually Require
Bulk senders need a working List-Unsubscribe-Post header, not just a link in the footer. It is two headers and an endpoint, and getting it wrong quietly costs you inbox placement.
How to Warm Up a New Sending Domain
A new domain has no reputation, and sending 50,000 messages on day one is the fastest way to get one you do not want. The ramp is boring, mechanical, and mostly about who you send to rather than how many.
Shared or Dedicated Sending Domain: How to Actually Choose
A shared domain gets you sending today on someone else's warmed reputation. A dedicated domain makes your reputation yours, including the bad parts. The decision is mostly about volume, and the threshold is lower than people think.
Recording a Bounce Is Not the Same as Honouring It
Most systems parse bounce webhooks into a table and then never read it back. A feedback loop you record but never enforce is not a defense. Here is what enforcement actually looks like in the send path.
What a 13.8% Bounce Rate Does to an AWS SES Account
AWS puts a sending account under review at a 5% bounce rate and suspends it at 10%. Here is what actually happens when you cross that line, why the cause is almost never your list, and how to get back under it.
Per-User Inbox Provisioning for Multi-Tenant Agent SaaS
You're building an agent product where every end user gets their own agent. Each of those agents needs its own inbox, and provisioning must be instant, isolated, and billable. Here's the pattern.
Web Bot Auth: Signing Outbound Agent Webhooks with HTTP Message Signatures
What RFC 9421 HTTP Message Signatures and the IETF Web Bot Auth draft specify, what signing webhooks with them takes, and what Lumbox signs its webhooks with today.
OAuth for MCP Servers: Authenticating Agents, Not Humans
What the MCP authorization spec asks for (OAuth 2.1, PKCE, RFC 9728 metadata, client registration), where API keys still fit, and exactly what Lumbox implements today.
Event-Driven Email Agents with Inngest and Lumbox
Connect Lumbox's email.received webhook to Inngest through a transform, verify the HMAC signature, and wait for verification codes with step.waitForEvent without losing early or dropped events.
Durable Email Workflows with Temporal and Lumbox
Temporal handles the hardest parts of distributed workflows: retries, durability, long-running operations. Lumbox's long-poll email endpoints plug into Temporal activities, even if the wait is hours.
Mastra + Lumbox: TypeScript-First Agent Email in 30 Lines
Mastra is the TypeScript answer to LangChain: workflows, agents, tools, evals, all in one package. Add Lumbox and your Mastra agents can send, receive, and verify email in native TS.
LlamaIndex + Lumbox: Treat Your Inbox as a Queryable Knowledge Source
Turn an agent's Lumbox inbox into a LlamaIndex knowledge source: one Document per email, webhook-driven updates, metadata filters, and citations back to the exact email.
AX (Agent Experience): What Email APIs Should Look Like for Agents, Not Humans
Developer Experience won the 2010s. Agent Experience (AX) will win the 2020s. Here's what it means for email APIs, and what a well-designed agent-first surface looks like.
Email as Memory for AI Agents
Agent memory systems are obsessed with vector stores. But humans have a perfectly good, addressable, persistent memory primitive: the inbox. Here's why email is the under-used memory substrate for agents.
Pydantic AI + Lumbox: Type-Safe Email Tools for Agents
Pydantic AI validates tool arguments and return values. Use that for Lumbox email tools: reject invented inbox ids, type the OTP response, and pick between ModelRetry and ToolFailed.
Infraforge vs Lumbox: Deliverability-First vs Agent-Native Email
Infraforge sells cold-email sending infrastructure: domains, dedicated IPs and prewarmed mailboxes. Lumbox gives agents inboxes that parse codes on arrival. Your mail's direction decides.
Unipile vs Lumbox: Unified Messaging API vs Agent-First Email
Unipile is a unified messaging API: LinkedIn, WhatsApp, Gmail, Outlook, one SDK. Lumbox is purpose-built for AI agent email. Here's when you pick each.
Give Your Replit Agent a Real Email Inbox with Lumbox
Replit Agent builds and tests apps but cannot read an inbox. Give the app a Lumbox key as a Replit Secret to verify its signup emails end to end and to receive mail of its own.
Give Your Sim Studio Agent an Email with Lumbox
Sim Studio is a visual agent builder: drag, drop, ship. But agents built visually hit the same signup walls. Here's how to wire Lumbox as a block so your Sim Studio flow can pass email verification.
LangGraph + Lumbox: Email as a State Transition
LangGraph models agents as state machines. Email is naturally a state transition: waiting for verification is a node, receiving the OTP is the edge. Here's how to model email flows as LangGraph nodes.
Email as Identity for AI Agents: The First-Class Primitive
Usernames, OAuth tokens, and API keys solve the machine-to-machine problem. None of them solve the machine-to-internet problem. Email is still the universal identity layer of the web, and agents need one of their own.
Give Your LiveKit Voice Agent an Email Inbox with Lumbox
Voice agents promise follow-ups they cannot speak. Wire a LiveKit agent to a Lumbox inbox with two function tools: one emails the caller a summary, one waits for a file they send mid-call.
What to Do When Gmail Bans Your AI Agent (And How to Avoid It Next Time)
Gmail send limits, bounce blocks and disabled accounts need different fixes. How to tell which one hit your agent, what Google's policies say, and how to move agent mail off Gmail.
Build an Email Agent with Google ADK and Lumbox
Google ADK tools are plain Python functions. Two async Lumbox tools give an ADK agent its own inbox and OTP codes, with session state, timeouts and webhook signatures handled correctly.
Give Your Browser Use Agent an Email Inbox with Lumbox
Browser Use can fill a signup form but has no mailbox. Give each run its own Lumbox inbox and a custom tool that waits for the verification email and returns codes and links.
Building Agent-as-a-Service Products: Why Email Is the Missing Infrastructure Layer
Every AaaS platform eventually needs email infrastructure. Here's how to architect the email layer for multi-tenant agent platforms without rebuilding it from scratch.
Email Parsing for AI Agents: From Raw MIME to Structured JSON
A technical deep-dive into why email parsing is deceptively hard for AI agents, and how to go from raw MIME nightmares to clean structured JSON with reliable OTP extraction.
Best Email APIs for AI Agents Compared: Lumbox vs AgentMail vs Building Your Own (2026)
A fair, technical comparison of every approach to giving AI agents email capabilities, from purpose-built APIs like Lumbox and AgentMail to DIY solutions with Gmail API or self-hosted Postal.
How to Add Email to AutoGen Multi-Agent Workflows
A step-by-step tutorial for integrating Lumbox email capabilities with Microsoft AutoGen, including custom tools, multi-agent coordination, and isolated inboxes per agent.
The 2026 Agentic AI Stack: Where Email Infrastructure Fits
A no-hype breakdown of the agentic AI stack in 2026: LLMs, orchestration frameworks, protocols like MCP and A2A, and the infrastructure primitives (including email) that make agents actually work.
Email Inbox API: Rate Limits, Quotas, and Best Practices
Understanding rate limits helps you design reliable agent workflows. Here are the limits that matter, how to avoid hitting them, and patterns for high-throughput email automation.
MCP Email Server for Claude and Cursor: Full Setup Guide
Connect Lumbox to Claude Desktop, Claude Code, or Cursor using the Model Context Protocol. No custom code. Just add the config and your AI tool gains full email capability.
Solving the 2FA Problem: How AI Agents Handle Email-Based Authentication
Two-factor authentication is the single biggest blocker for autonomous AI agents. Here's the architecture for solving email-based 2FA with dedicated inboxes and OTP extraction.
AI Email Triage: Automatically Categorize and Route Inbound Email
Lumbox tags each inbound email with a category from weighted keyword rules, not a model. How the score works, where it misfires, and how to route and label on it.
Email as a State Machine: Build Reliable AI Workflows Around Email
Approval flows over email need explicit states, a durable cursor and sends that are safe to repeat. A worked design on a Lumbox inbox, plus the edge cases that break naive loops.
Automating SaaS Onboarding: Email Verification with AI Agents
AI agents can test your SaaS onboarding flow end to end, including email verification. Here is how to automate signup, email verification, and first-login testing with a real inbox API.
Temp Email API for Developers: Disposable Inboxes with a Real API
Temp-mail sites are built for people, not scripts. A temp email API keeps the disposable inbox and adds access control, a lifecycle you set, parsed OTP codes and sending.
LangChain Email Tool: Add Inbox and OTP Tools to Any Chain
Build a LangChain tool that creates inboxes and retrieves OTP codes. Plug it into any agent, chain, or ReAct loop to give your LangChain app full email capability.
Email for RPA: Add Email Capability to Robotic Process Automation
RPA bots often hit a wall when a workflow requires email verification. Lumbox's API solves this with programmatic inbox creation and OTP extraction for any RPA platform.
Vercel AI SDK + Email: Add Inbox Tools with useTools
Extend your Vercel AI SDK application with email capabilities. Define inbox and OTP tools using the AI SDK tool API and connect them to Lumbox's REST endpoints.
CrewAI Email Integration: Add Email Tools to Your Crew
Build CrewAI email tools on the Lumbox REST API: create inboxes, wait for OTP codes and send mail, with tool caching, retries and per-agent tool access set up correctly.
Build an Email Monitoring Bot in Python
Monitor an inbox for specific emails and trigger actions when they arrive. A practical Python script that uses webhooks or long-polling to watch for emails matching a pattern.
Send Email from an AI Agent: Outbound Email API Guide
AI agents can send emails, reply to threads, and forward messages using Lumbox's outbound API. No SMTP setup, no Nodemailer, just a POST request.
Custom Domain Email for AI Agents: Use Your Own Domain
Set up your own domain for AI agent inboxes on Lumbox: picking a subdomain, the DNS records, verification, and creating inboxes on your domain before you hand out an address.
Bring Your Own SMTP: Sending Agent Email From Your Domain
Your AI agent should send email from your brand's domain, not a shared sender pool. Lumbox's BYOS feature connects AWS SES, SendGrid, Postmark, or raw SMTP and keeps the agent tooling intact.
AI Email Parsing: Extract Structured Data from Any Email
Raw email content is unstructured text. Lumbox parses every inbound email and returns OTP codes, verification links, categories, and summaries as structured JSON automatically.
Receive Email Programmatically: REST API vs IMAP vs Webhooks
IMAP, REST polling, long-polling, server-sent events and webhooks can all receive email in code. What each costs in setup, delay and rate limit, and which one to use when.
Email Threading for AI Agents: Multi-Turn Conversations via Email
Threads let an AI agent have multi-turn conversations over email. Here is how email threading works technically and how to use it in your agent to maintain conversation context.
SPF, DKIM, and DMARC: Email Authentication for AI Agent Outbound
What SPF, DKIM and DMARC each check, the limits that break real records, why DKIM usually carries DMARC for agent mail, and what to publish for a custom domain on Lumbox.
Using Webhooks to Trigger AI Agent Workflows From Inbound Email
Long-polling works great for synchronous agent flows. But for event-driven architectures (queues, serverless functions, n8n workflows), webhooks are the right primitive. Here's how to wire them up.
Email-Gated Content: How AI Agents Access It with Web Scraping
Reports and datasets often sit behind an enter-your-email form. How an agent with its own long-lived inbox gets the emailed link, and the limits that keep it a fair trade.
AI Agent Account Registration: Automate the Full Signup Flow
Automate complete account registration flows with an AI agent: fill forms, receive verification email, extract OTP, complete signup. A practical guide with working code.
How to Extract OTP Codes from Email Automatically
Lumbox extracts OTP codes with six digit-only regex patterns over the subject and text body. Exactly what they match, what they miss, and a fallback for the rest.
Disposable Email API for Testing: Create Isolated Inboxes Per Test
Shared test email accounts cause flaky tests and OTP collisions. A disposable email API creates a fresh isolated inbox per test run, guaranteed to receive only that test's emails.
Why Email Threading Matters for Autonomous AI Agents
An agent that replies without proper Message-ID and References headers breaks email threading for the human on the other end. Here's why threading is a first-class primitive, not an afterthought.
OpenAI Assistants API with Email: Add Inbox Tools to Your Assistant
The Assistants API was removed on August 26, 2026. Here is how to move an assistant's inbox, OTP and send tools to the Responses API, with the Lumbox calls behind them unchanged.
AutoGPT Email Integration: Give Your Agent a Real Inbox
Give an AutoGPT Platform agent a real inbox: chain Send Web Request blocks to the Lumbox API for signups and OTP codes, or connect the hosted MCP server with the MCP Tool block.
Email Webhooks vs Polling: Which to Use for AI Agents
Polling loops waste resources and miss timing windows. Webhooks fire instantly but require a public endpoint. Long-polling gives you the best of both. Here is when to use each.
How to Give Any AI Agent Its Own Email Address
A step-by-step guide to provisioning dedicated email addresses for AI agents. Works with LangChain, CrewAI, AutoGen, Claude, and any other agent framework.
Sending Bulk Marketing Email From Your AI Agent
How an AI agent can send bulk email through Lumbox: 100 messages per request via Resend, one-click unsubscribe, suppression, and why it is only for people who opted in.
Selenium Email OTP Automation: Extract Verification Codes
Automate OTP verification in Selenium tests without IMAP polling. Create an inbox per test with Lumbox's REST API and read the emailed code in Python or Java.
Cypress Email Verification Testing with a Real API
Add email OTP verification to your Cypress test suite using Lumbox. Create isolated inboxes per test, extract OTP codes via API, and keep your tests deterministic.
Playwright Email OTP Verification: Complete Guide
Stop writing fragile IMAP polling loops in your Playwright tests. Use Lumbox's long-poll API to get OTP codes instantly, without race conditions or sleep timers.
Lumbox vs Mailosaur: Email Testing API for AI and QA Teams
Mailosaur is built for QA testing teams. Lumbox is built for AI agents. If you need email for automation scripts, AI workflows, or MCP integrations, here is what to choose.
Lumbox vs Gmail API: Why Dedicated Agent Email Wins
Gmail's API is designed for humans managing their own inbox, not for thousands of AI agents each needing isolated, ephemeral email addresses. Here's a direct comparison.
Lumbox vs MailSlurp: Email API Comparison for Developers
MailSlurp is a wide email and SMS testing platform with its own MCP server. Lumbox is narrower: agent inboxes with codes parsed on arrival and external sends on the free plan.
Lumbox vs Mailinator: Which Email API Is Better for AI Agents?
Mailinator's free inboxes are public and receive-only, and its API is for subscribers. Lumbox gives each agent a private inbox that parses codes and can reply.
Email API for Node.js and TypeScript: Inbox, OTP, and Send
Use Lumbox from Node.js or TypeScript to create inboxes, wait for verification emails, extract OTP codes, and send replies. No IMAP, no SMTP config.
Email API for Python Developers: Send and Receive Programmatically
A practical guide to using Lumbox's Python-friendly REST API for creating inboxes, waiting for emails, extracting OTPs, and sending replies from your Python scripts.
Adding Email to OpenAI Agents SDK with Lumbox
OpenAI's Agents SDK makes it easy to define tools, but email is conspicuously absent from the standard toolkit. Here's how to add a full email primitive (create, wait, extract OTP) in under 50 lines.
Make.com Email Verification Automation with Lumbox
Use Make's HTTP app to create a Lumbox inbox, wait for the verification code or link, and delete the inbox afterwards, with the timeout and error-handler settings that keep it reliable.
n8n Email OTP Workflow: Automate Verification Codes
Build a reliable OTP extraction workflow in n8n using Lumbox's REST API. No custom code required, just HTTP nodes and a bit of logic.
The Complete Email Infrastructure Stack for AI Agents in 2026
Email infrastructure for AI agents is six distinct layers: inbox management, inbound processing, wait semantics, outbound sending, webhooks, and domain identity. Here's the complete picture.
Using Claude with MCP to Read and Send Email Autonomously
The Model Context Protocol turns email from a destination into a tool Claude can call. Here's how to wire Lumbox's MCP server into a Claude agent that reads, replies, and acts on email without human involvement.
Building Web Scrapers That Handle Account-Gated Content
Scraping data you are allowed to see behind a login: reuse the saved session, log back in with an emailed code or magic link, and stop instead of rotating accounts when blocked.
Stop Polling Your Email. Use Long-Poll Instead.
Almost every email-waiting loop for AI agents is the same: sleep, check, repeat. It works. It is also inefficient, slow, fragile, and completely unnecessary. Here's the better pattern.
80% of the Internet Requires Email Verification. Your Agent Doesn't Have One.
No study backs the 80% figure, but an emailed code or link gates most signups an agent attempts. What an agent inbox fixes, what it cannot, and the two calls involved.
Custom Domain Email for AI Agents: Give Your Bot a Professional Identity
Why AI agents that write to customers should send from your own domain, what it changes for trust and reputation, and how to lay out per-agent addresses and keys.
Email Isolation in Multi-Agent Systems: Why One Inbox Per Task Matters
Multi-agent failures from shared email are silent, intermittent, and hard to debug. A 20% failure rate with no error trace. The fix is inbox isolation: one inbox per task, by construction.
Disposable Email Inboxes for AI Testing and QA Automation
An AI agent running QA on a signup flow needs an inbox the harness owns, a wait that survives slow model steps, and checks on the inbox itself, not the agent's own report.
Automating Account Registration With AI Agents: The Complete Guide
A complete seven-step pipeline for automated account registration with Playwright and Lumbox, handling OTP codes, magic links, session persistence, and parallel scale.
CrewAI + Email Verification: Build Agents That Access Any Web Service
CrewAI crews fail at email verification: they can research, plan, and execute, but can't receive an OTP. This guide adds Lumbox email tools to any CrewAI agent in minutes.
Programmatic Email Inboxes: The Core Primitive for Agent Infrastructure
LLMs, browser automation, code execution, vector search: all covered. But the ability to create an inbox on demand, use it for a task, and delete it? That primitive has been missing until now.
Why Using Your Personal Email for AI Agents Is a Mistake
It takes 20 minutes to wire your Gmail to an agent. It takes two weeks for it to catastrophically fail: suspended account, flooded inbox, broken OAuth tokens, and OTP collisions.
The Hidden Bottleneck in Autonomous AI Systems: Email
LLMs, browser automation, code execution: all covered. But one infrastructure gap blocks agents from participating in the real internet: email. No one is talking about it.
Why AI Agents Can't Sign Up for Anything Online
Your agent can browse the web, fill forms, and click submit. Then it hits a wall: 'Please verify your email address.' With no inbox, the task fails silently. Here's the fix.
MCP Email Server: Giving Claude and Any MCP Client a Real Inbox
Lumbox ships a native MCP server. Any MCP-compatible agent (Claude Desktop, Claude Code, Cursor) can provision inboxes, extract OTPs, and receive emails without any custom integration code.
LangChain Email Tool: Add Real Inbox and OTP Support to Any Chain
LangChain agents break at email verification: they can fill the form but can't receive the OTP. This guide wraps Lumbox as a native LangChain tool so your agents handle the full signup flow.
Why IMAP Is Dead for AI Agents (And What to Use Instead)
IMAP was designed for humans checking email once an hour, not for thousands of parallel agents each racing to receive an OTP within seconds. Here's why it fails and what replaces it.
Handling OTP Verification with Headless Browsers and AI Agents
A headless script knows when a code is sent and an AI agent does not. How to wait for emailed OTPs in each case, handle expiry and resends, and tell codes from links.
Why Your AI Agent Needs Its Own Email Inbox
LLMs are evolving from chatbots into autonomous agents. But without a dedicated email identity, they're stuck using the developer's personal inbox, a security risk that collapses at scale.
Subscribe to the logs
Engineering updates, product launches, and thoughts on building the email layer for AI agents.