HTML vs plain text email: how your AI agent should choose

Your AI agent just sent 500 HTML emails. A third landed in spam. The tracking pixel triggered Gmail's content filter, the CSS rendered broken on Outlook mobile, and three recipients flagged the message as promotional before reading a word.

Meanwhile, plain text emails from the same sender address hit the primary inbox at nearly double the rate.

Format choice is one of those decisions that seems cosmetic but actually determines whether your agent's email gets read or buried. For AI agents sending at volume, the stakes are higher than they are for a human clicking "send" on a one-off newsletter. Here's how the two formats compare, when each one wins, and how an agent can pick the right format on every individual send.

HTML vs plain text at a glance#

Plain text wins on deliverability and inbox placement. HTML wins on presentation, branding, and tracking. For most AI agent workflows, the right answer isn't one or the other. It depends on what your agent is trying to accomplish with each specific email, and smart agents can evaluate that question on every single send rather than locking in a campaign-level toggle.

Why format matters more for agents than humans#

When a human sends an email, they're usually sending one. Maybe a handful. The format decision is low-stakes because volume is low and reputation risk is negligible.

Agents operate differently. An agent sending email at scale might provision an inbox, fire off 200 outreach messages in an afternoon, and move on to the next task. At that volume, a bad format choice compounds fast. Every HTML email that lands in spam instead of the primary inbox is a wasted send that also damages the sending domain's reputation score.

The research backs this up. Studies from WarmForge and SendCheckIt both found that plain text emails are less likely to trigger spam filters, with some data showing roughly 42% higher open rates in cold outreach scenarios. That gap isn't about aesthetics. It reflects how mailbox providers like Gmail and Outlook score inbound messages.

Gmail's content filters parse HTML structure, flag hidden tracking pixels, and penalize emails that look like bulk marketing. Plain text messages skip most of those checks because there's nothing to parse. No images, no embedded styles, no invisible 1x1 pixel that phones home when the recipient opens the message. For agents that need to protect their deliverability, this difference is worth paying attention to.

When plain text wins#

Plain text is the right call in three situations.

Cold outreach. If the recipient doesn't know your agent (or the entity it represents), plain text looks like a real person wrote it. HTML screams "automated campaign." For any first-touch message where inbox placement matters, plain text is the safer default.

Domain warm-up. New sending domains need to build reputation gradually. Sending HTML emails with tracking pixels from a fresh domain is one of the fastest ways to get flagged. Plain text during the warm-up period (typically the first two to four weeks) keeps the domain clean while reputation builds.

Transactional follow-ups that feel personal. Password reset confirmations, appointment reminders, and quick status updates often perform better as plain text. They look like something a colleague would send, not something a marketing platform generated.

When HTML makes sense#

HTML isn't always the wrong choice. There are legitimate cases where your agent should use it.

Branded communications. If your agent sends on behalf of a company with visual identity standards (logo, colors, layout), HTML is the expected format. A plain text email from a brand can actually look suspicious to recipients who expect polished templates.

Emails with structured data. Order confirmations, invoices, dashboards, and reports benefit from tables, headers, and formatting that plain text can't provide. Trying to represent a five-column order summary in plain text is painful for the reader.

Messages where tracking matters. If your agent needs to know whether a recipient opened the email or clicked a specific link, HTML is required for open tracking (via pixel) and provides cleaner click tracking. Plain text can track clicks by wrapping links through a redirect, but open tracking is impossible without HTML.

The multipart/alternative approach#

Here's the option most guides skip: you don't have to choose one format. The MIME standard supports multipart/alternative, which sends both an HTML version and a plain text version in the same message. The recipient's mail client picks whichever it prefers to display.

This sounds like the best of both worlds, and it often is. But there are trade-offs worth knowing at scale.

First, message size roughly doubles. For a single email, that's irrelevant. For an agent sending thousands per day, it adds up in bandwidth and processing time.

Second, some spam filters check whether the plain text and HTML parts actually match. If your agent auto-generates an HTML email and then strips the tags to create the plain text version, the content should be nearly identical. Significant divergence between the two parts can itself trigger a spam flag.

Third, not every mail client handles multipart the same way. Most modern clients do the right thing, but older corporate email systems sometimes display both parts or mangle the plain text fallback.

For most agent workflows, multipart/alternative is a reasonable default for high-value messages where you want both deliverability safety and visual presentation. For cold outreach at volume, pure plain text still wins.

How an agent selects format dynamically#

The most interesting angle here is that agents don't have to make a single format decision for an entire campaign. They can choose per recipient, per message, per step in a sequence. This per-message intelligence is where agent-driven email actually outperforms traditional email service providers. A marketing platform lets you pick HTML or plain text for a campaign. An agent can evaluate every single send independently.

Here's what a smart format-selection loop looks like:

1. Check the context. Is this a cold first touch, a warm follow-up, or a transactional message? Cold outreach defaults to plain text. Transactional messages with structured data default to HTML.
2. Check the recipient history. If the agent has sent to this address before and has engagement data, use it. Low open rates on previous HTML sends? Switch to plain text. High engagement with HTML templates? Keep them.
3. Check the domain age. If the sending domain is less than 30 days old, default to plain text regardless of other signals. Domain reputation is too fragile during warm-up.
4. Monitor deliverability signals. If bounce rates spike or inbox placement drops across a batch, the agent should automatically fall back to plain text for subsequent sends. This is the feedback loop that no human-managed campaign tool provides natively.

function selectFormat(context: SendContext): "text" | "html" | "multipart" {
  // New domains always send plain text during warm-up
  if (context.domainAgeDays < 30) return "text";

  // Cold outreach defaults to plain text
  if (context.recipientRelationship === "cold") return "text";

  // If prior sends had low engagement, switch to plain text
  if (context.priorOpenRate !== null && context.priorOpenRate < 0.15) {
    return "text";
  }

  // Branded or transactional messages use multipart
  if (context.messageType === "transactional" || context.requiresBranding) {
    return "multipart";
  }

  // Default: plain text is the safer choice
  return "text";
}

For agents running multi-step sequences, the pattern is even more nuanced. Start with plain text for the first touch (highest deliverability risk). If the recipient opens the first message and clicks through, later steps can use HTML or multipart. If there's no engagement signal, staying with plain text maximizes the chance of reaching the inbox on follow-ups.

What this means for your agent#

If you're building an agent that sends email, default to plain text for outreach and cold messages. Use HTML or multipart for branded and transactional emails. And build the logic to switch dynamically based on engagement data and deliverability signals.

The format decision isn't something to set once and forget. It's a variable your agent should re-evaluate with every send. LobsterMail gives your agent control over format at the per-message level, so it can implement exactly this kind of dynamic selection. If you want to see what that looks like in practice, get your agent its own inbox and start testing format strategies on real sends.