An Inbox That Answers Itself

// 01 — The problem

Enterprises answer the same email a thousand times, and a server is the wrong place to do it.

A large share of inbound business email is repetitive: the same handful of questions, asked by different people, at unpredictable times of day. Hiring a person to answer them doesn't scale with volume. Standing up a traditional backend — a mail processor, a queue, a worker fleet — to automate it means paying for capacity around the clock for traffic that arrives in bursts, if it arrives at all.

And an LLM sitting behind a public-facing email address has its own failure mode: asked a question it was never scoped to answer, it will answer anyway, fluently and off-brand, unless something upstream of the model stops it.

Four constraints shaped the build:

So the goal wasn't "wire an LLM to an inbox." It was: answer real email, inside the real thread, from a single bounded subject, on infrastructure that costs nothing while nobody is emailing.

// 02 — My responsibilities

• → Defined the product: a single email address that reads inbound mail, answers from a bounded topic, and replies inside the same thread.
• → Chose Cloudflare's email stack end to end — Email Routing for the trigger, an Email Worker for compute, AI Search for retrieval and generation — over a self-hosted mail processor.
• → Built a hand-rolled MIME parser from scratch: subject and Message-ID/References extraction, multipart boundary walking, quoted-printable and base64 decoding, RFC 2047 encoded-header decoding.
• → Designed the email threading model — carrying In-Reply-To and References forward and minting a fresh Message-ID per outbound send — so multi-turn conversations stay in one thread instead of starting over each reply.
• → Scoped the assistant at the prompt layer: every call frames the question as a lookup against one subject and instructs the model to decline anything else, rather than trusting the sender's message to stay on topic.
• → Wired the chat completions call to a Cloudflare AI Search instance, treating it as the single source of grounded knowledge rather than the model's own pretraining.
• → Designed the identity split between the sending address and the reply-to address, so the domain that sends mail and the address people actually reply to can be managed and reputation-scored independently.
• → Implemented the dual-send delivery: the sender's reply and an internal BCC audit copy as two independent envelope sends, since Email Workers has no native BCC header behaviour.
• → Implemented failure handling via message.setReject so a broken AI call or malformed MIME bounces with a reason instead of disappearing silently.
• → Modelled the full cost per interaction across Workers compute, Email Routing, and the AI Search call, and verified it against Cloudflare's published pricing.
• → Documented every binding, secret and permission needed to run the Worker from the dashboard alone — no wrangler, no CLI deploy step required.

// 04 — Technical insights

// Threading: reference the message we're replying to so mail clients
// nest this reply into the existing conversation instead of starting a new one.
const threadReferences = [references, messageId].filter(Boolean).join(" ");

const rawReply = buildRawEmail({
  from: `${FROM_NAME} <${FROM_ADDRESS}>`,
  replyTo: REPLY_TO_ADDRESS,
  to: message.from,
  subject: replySubject,
  body: aiReplyText,
  inReplyTo: messageId,
  references: threadReferences,
});

// A send binding delivers to exactly the recipients it's called with —
// there is no BCC header, so the audit copy is a second, independent send.
await env.SEND_EMAIL.send(new EmailMessage(FROM_ADDRESS, message.from, rawReply));
await env.SEND_EMAIL.send(new EmailMessage(FROM_ADDRESS, BCC_ADDRESS, rawBccCopy));

// 05 — Results

A real inbox, a real thread, and a cost per email measured in fractions of a cent.

What this looks like for an enterprise considering the same pattern:

• Automated first-response coverage for a known category of inbound email, with no on-call rotation required to keep it running.
• A measurable reduction in manual reply volume for the subset of email that's genuinely repetitive.
• A cost structure that tracks actual usage rather than provisioned capacity — a quiet month costs nothing beyond the odd email that does arrive.
• An audit copy of every automated reply, landing in an internal mailbox the moment it's sent, with no separate logging infrastructure.
• A deployment that's one file: reviewable, pasteable, and auditable without a build pipeline standing between the source and what's running.

Cost breakdown per interaction

// 06 — What I learned

The AI call is the easy part. Email is the hard part.

// Technologies used

// Appendix — system at a glance