AI Agent for Gmail & Email: Automate Inbox Management, Drafts & Follow-ups

The average professional spends 2.5 hours per day on email. An AI agent handles 80% of it — triaging, drafting, following up — while you focus on work that matters. Here's exactly how to build one.

The Email Problem (and Why Filters Aren't Enough)

Gmail filters can sort emails into folders. Rules can auto-archive newsletters. Labels can color-code senders. But none of that helps with the actual work:

• Reading each email to understand what it needs
• Deciding the priority and urgency
• Writing thoughtful replies
• Following up when someone doesn't respond
• Extracting action items and adding them to your task list
• Summarizing long email threads before meetings

That's the work an AI email agent automates. Not replacing your judgment — but handling the processing overhead so you only deal with emails that genuinely need your attention.

5 Email Agent Capabilities

Architecture: The Email Agent Stack

┌─────────────────────────────────────────────┐
│              Gmail / Email Provider          │
│    Push notifications via Pub/Sub or IMAP    │
└────────────────┬────────────────────────────┘
                 │
                 ▼
┌─────────────────────────────────────────────┐
│            Email Processing Pipeline         │
│  ┌─────────┐  ┌──────────┐  ┌───────────┐  │
│  │ Fetch & │→ │ Classify │→ │ Route to  │  │
│  │ Parse   │  │ & Triage │  │ Handler   │  │
│  └─────────┘  └──────────┘  └───────────┘  │
├─────────────────────────────────────────────┤
│              Action Handlers                 │
│  ┌─────────┐ ┌──────────┐ ┌────────────┐   │
│  │ Draft   │ │ Extract  │ │ Follow-up  │   │
│  │ Reply   │ │ Actions  │ │ Scheduler  │   │
│  └─────────┘ └──────────┘ └────────────┘   │
├─────────────────────────────────────────────┤
│            Context Layer                     │
│  Contact history │ Calendar │ Writing style  │
│  Past threads    │ CRM data │ Preferences   │
└─────────────────────────────────────────────┘

Build: Inbox Triage Agent

import Anthropic from "@anthropic-ai/sdk";
import { google } from "googleapis";

const anthropic = new Anthropic();
const gmail = google.gmail({ version: "v1", auth: oAuth2Client });

async function triageInbox() {
  // Fetch unread emails
  const { data } = await gmail.users.messages.list({
    userId: "me",
    q: "is:unread",
    maxResults: 50,
  });

  if (!data.messages) return [];

  const results = [];

  for (const msg of data.messages) {
    const email = await gmail.users.messages.get({
      userId: "me",
      id: msg.id,
      format: "full",
    });

    const headers = email.data.payload.headers;
    const from = headers.find(h => h.name === "From")?.value;
    const subject = headers.find(h => h.name === "Subject")?.value;
    const date = headers.find(h => h.name === "Date")?.value;
    const body = extractBody(email.data.payload);

    // Get sender history
    const senderHistory = await getSenderHistory(from);

    // Classify with Claude
    const response = await anthropic.messages.create({
      model: "claude-sonnet-4-20250514",
      max_tokens: 300,
      messages: [{
        role: "user",
        content: `Triage this email. Return JSON:
{
  "priority": "urgent|important|fyi|noise",
  "category": "client|team|vendor|newsletter|notification|spam",
  "needs_reply": true/false,
  "reply_deadline": "today|this_week|no_rush|none",
  "summary": "1-sentence summary",
  "action_items": ["list of actions needed"],
  "suggested_labels": ["gmail labels to apply"]
}

Sender: ${from}
Subject: ${subject}
Sender history: ${senderHistory.replyRate}% reply rate, ${senderHistory.avgResponseTime}h avg response
Body: ${body.substring(0, 2000)}`
      }],
    });

    const triage = JSON.parse(response.content[0].text);

    // Apply labels in Gmail
    await applyLabels(msg.id, triage);

    // If noise, auto-archive
    if (triage.priority === "noise") {
      await gmail.users.messages.modify({
        userId: "me",
        id: msg.id,
        requestBody: { removeLabelIds: ["INBOX"] },
      });
    }

    results.push({ from, subject, ...triage });
  }

  return results;
}

async function applyLabels(messageId, triage) {
  const labelMap = {
    urgent: "IMPORTANT",
    important: "CATEGORY_PERSONAL",
  };

  const labelId = labelMap[triage.priority];
  if (labelId) {
    await gmail.users.messages.modify({
      userId: "me",
      id: messageId,
      requestBody: { addLabelIds: [labelId] },
    });
  }
}

// Generate morning digest
async function generateDigest(triageResults) {
  const urgent = triageResults.filter(r => r.priority === "urgent");
  const important = triageResults.filter(r => r.priority === "important");
  const fyi = triageResults.filter(r => r.priority === "fyi");
  const noise = triageResults.filter(r => r.priority === "noise");

  return `📬 Morning Email Digest

🔴 Urgent (${urgent.length}):
${urgent.map(e => `  • ${e.from}: ${e.summary}`).join("\n")}

🟡 Important (${important.length}):
${important.map(e => `  • ${e.from}: ${e.summary}`).join("\n")}

🔵 FYI (${fyi.length}):
${fyi.map(e => `  • ${e.subject}`).join("\n")}

⚪ Auto-archived (${noise.length}): newsletters, notifications
`;
}

Build: Smart Draft Agent

async function draftReply(messageId) {
  // Get the full thread
  const message = await gmail.users.messages.get({
    userId: "me", id: messageId, format: "full",
  });

  const threadId = message.data.threadId;
  const thread = await gmail.users.threads.get({
    userId: "me", id: threadId, format: "full",
  });

  // Build conversation history
  const conversation = thread.data.messages.map(msg => {
    const headers = msg.payload.headers;
    return {
      from: headers.find(h => h.name === "From")?.value,
      date: headers.find(h => h.name === "Date")?.value,
      body: extractBody(msg.payload),
    };
  });

  // Get sender relationship context
  const senderEmail = extractEmail(conversation[0].from);
  const pastEmails = await searchPastEmails(senderEmail, 10);
  const contactInfo = await getCRMInfo(senderEmail);

  // Check calendar for scheduling context
  const calendar = await getUpcomingEvents(7);

  // Load user's writing style
  const writingStyle = await getWritingStyle();

  const response = await anthropic.messages.create({
    model: "claude-sonnet-4-20250514",
    max_tokens: 1000,
    system: `You draft email replies matching this person's style:
${writingStyle}

Rules:
- Match their typical tone (formal/casual based on relationship)
- Keep replies concise unless the topic needs detail
- Include specific references to the email content
- Never make commitments about dates/times without calendar check
- If scheduling, suggest times from the available slots below
- Sign off the way they typically do`,
    messages: [{
      role: "user",
      content: `Draft a reply to this email thread.

Thread:
${conversation.map(c =>
  `From: ${c.from}\nDate: ${c.date}\n${c.body}`
).join("\n---\n")}

Relationship context:
${contactInfo ? `Company: ${contactInfo.company}, Role: ${contactInfo.role}` : "No CRM data"}

Past email tone: ${pastEmails.length > 0
  ? analyzeTone(pastEmails)
  : "No history — use professional-friendly tone"}

Available calendar slots (next 7 days):
${calendar.availableSlots.map(s =>
  `${s.day}: ${s.times.join(", ")}`
).join("\n")}

Draft the reply. Just the body text, no subject line.`
    }],
  });

  // Create draft in Gmail
  const draft = await gmail.users.drafts.create({
    userId: "me",
    requestBody: {
      message: {
        threadId,
        raw: createRawEmail({
          to: extractEmail(conversation.at(-1).from),
          subject: `Re: ${getSubject(message)}`,
          body: response.content[0].text,
          inReplyTo: message.data.id,
        }),
      },
    },
  });

  return {
    draftId: draft.data.id,
    preview: response.content[0].text,
  };
}

Build: Follow-up Tracker

async function checkFollowUps() {
  // Find sent emails with no reply
  const sentMessages = await gmail.users.messages.list({
    userId: "me",
    q: "in:sent after:" + daysAgo(14),
    maxResults: 100,
  });

  const needsFollowUp = [];

  for (const msg of sentMessages.data.messages || []) {
    const message = await gmail.users.messages.get({
      userId: "me", id: msg.id, format: "metadata",
      metadataHeaders: ["To", "Subject", "Date", "Message-ID"],
    });

    const headers = message.data.payload.headers;
    const to = headers.find(h => h.name === "To")?.value;
    const subject = headers.find(h => h.name === "Subject")?.value;
    const sentDate = new Date(headers.find(h => h.name === "Date")?.value);
    const daysSinceSent = (Date.now() - sentDate) / (1000 * 60 * 60 * 24);

    // Check if there's a reply in the thread
    const thread = await gmail.users.threads.get({
      userId: "me", id: message.data.threadId, format: "metadata",
    });

    const hasReply = thread.data.messages.some(m => {
      const from = m.payload.headers.find(h => h.name === "From")?.value;
      const msgDate = new Date(parseInt(m.internalDate));
      return from?.includes(extractEmail(to)) && msgDate > sentDate;
    });

    if (!hasReply && daysSinceSent >= 3) {
      needsFollowUp.push({
        to,
        subject,
        daysSinceSent: Math.round(daysSinceSent),
        threadId: message.data.threadId,
        messageId: msg.id,
      });
    }
  }

  // Generate follow-up drafts for emails > 5 days old
  for (const email of needsFollowUp.filter(e => e.daysSinceSent >= 5)) {
    await draftFollowUp(email);
  }

  return needsFollowUp;
}

async function draftFollowUp(email) {
  const response = await anthropic.messages.create({
    model: "claude-sonnet-4-20250514",
    max_tokens: 300,
    messages: [{
      role: "user",
      content: `Write a brief, friendly follow-up email.

Original subject: ${email.subject}
Sent to: ${email.to}
Days since sent: ${email.daysSinceSent}

Rules:
- Keep it short (2-3 sentences)
- Don't be passive-aggressive
- Reference the original topic naturally
- Suggest a specific next step
- Tone: friendly, professional, not pushy`
    }],
  });

  await gmail.users.drafts.create({
    userId: "me",
    requestBody: {
      message: {
        threadId: email.threadId,
        raw: createRawEmail({
          to: email.to,
          subject: `Re: ${email.subject}`,
          body: response.content[0].text,
        }),
      },
    },
  });
}

Build: Action Item Extractor

async function extractActionItems(messageId) {
  const message = await gmail.users.messages.get({
    userId: "me", id: messageId, format: "full",
  });

  const body = extractBody(message.data.payload);
  const from = message.data.payload.headers
    .find(h => h.name === "From")?.value;

  const response = await anthropic.messages.create({
    model: "claude-sonnet-4-20250514",
    max_tokens: 500,
    messages: [{
      role: "user",
      content: `Extract action items from this email. Return JSON:
{
  "action_items": [
    {
      "task": "description of what needs to be done",
      "assignee": "me|them|unclear",
      "deadline": "ISO date or null",
      "priority": "high|medium|low",
      "context": "relevant quote from email"
    }
  ],
  "decisions_made": ["list of decisions mentioned"],
  "questions_asked": ["list of questions needing answers"]
}

Only extract REAL action items — things someone committed to or
was asked to do. Don't invent tasks.

From: ${from}
Email: ${body}`
    }],
  });

  const extracted = JSON.parse(response.content[0].text);

  // Create tasks in your project management tool
  for (const item of extracted.action_items) {
    if (item.assignee === "me") {
      await createTask({
        title: item.task,
        deadline: item.deadline,
        priority: item.priority,
        source: `Email from ${from}`,
        link: getEmailLink(messageId),
      });
    }
  }

  return extracted;
}

Production System Prompt

const EMAIL_AGENT_PROMPT = `You are an email management agent
for a busy professional.

## Core Philosophy
You REDUCE email burden, not create more of it. Every action
should save the user time. If in doubt, flag for review rather
than act.

## Triage Rules
URGENT: From direct reports, manager, key clients. Contains
  words like "asap", "today", "critical", deadlines within 24h.
IMPORTANT: Requires a thoughtful reply. From known contacts.
  Has action items or decisions needed this week.
FYI: Updates, reports, newsletters the user has read before.
  CC'd emails where action isn't needed.
NOISE: Marketing, automated notifications, social media
  digests, promotional emails. Auto-archive these.

## Draft Rules
1. Match the user's writing style EXACTLY
2. Mirror the formality level of the incoming email
3. Keep replies 50% shorter than the original email
4. Never commit to dates/times without calendar verification
5. Never agree to anything financial without user approval
6. Include one clear next step or CTA
7. When declining, be gracious but clear

## Safety Rules (NON-NEGOTIABLE)
- NEVER send an email automatically. Always create DRAFTS
- NEVER share confidential information across contexts
- NEVER reply to emails that look like phishing
- Flag suspicious emails for manual review
- If an email involves legal, financial, or HR matters,
  flag for the user without drafting a reply
- Never forward emails to anyone without explicit instruction

## Learning
Track which drafts get edited vs sent as-is.
Note: heavily edited = style mismatch, adjust.
Note: sent as-is = good match, reinforce pattern.
`;

Tool Comparison: 8 Email AI Tools

Tool	Best For	Price	Custom Logic
Gemini in Gmail	Quick summaries, basic drafts	$20/mo (Workspace)	❌ None
Superhuman AI	Speed + AI drafts for power users	$30/mo	❌ Limited
Shortwave	AI-first email client, auto-triage	Free / $14/mo	⚠️ Some
Sanebox	Smart inbox filtering	$7/mo	❌ None
Spark	AI email writing + team inbox	Free / $8/mo	❌ Limited
Flowrite / Missive	Template-based AI replies	$5-15/mo	⚠️ Some
n8n + Gmail	Workflow automation	Free (self-host)	✅ Full
Custom Agent (this guide)	Full control, learns your style	~$5-15/mo (API)	✅ Full

Our recommendation: Try Shortwave if you want an AI-native email client that just works. Use Superhuman if speed is everything. Build custom when you need your agent to integrate with your CRM, project management, and calendar — or when you want it to truly learn your style.

Build Your Email Agent in 45 Minutes

Email Agent Safety Rules (Non-Negotiable)

1. Never auto-send. Always create drafts. Human reviews and hits send.
2. Never reply to phishing. Flag suspicious emails for manual review.
3. Never commit to money, dates, or contracts without explicit user approval.
4. Never forward or CC without explicit instruction.
5. Log everything. Every draft created, every email triaged, every action taken. You need an audit trail.
6. Rate limit drafts. Max 20 drafts per hour. If the agent is creating more, something is wrong.
7. Separate contexts. Work email agent doesn't access personal email data and vice versa.

7 Mistakes That Kill Email Agent Trust

What's Next

Start with triage only — classify and label your emails. Get comfortable with the accuracy. Then add draft generation for your most common reply types ("meeting scheduling", "quick questions", "status updates"). Finally, add follow-up tracking and action item extraction.

The goal isn't zero-email. It's zero wasted time on email. Your agent handles the processing. You handle the thinking. Together, 2.5 hours becomes 30 minutes — and you never miss a follow-up again.