Automating Email with AI: From Inbox Zero to Zero Touch

// email-classifier.ts
import Anthropic from "@anthropic-ai/sdk";

export type EmailCategory =
  | "newsletter"
  | "sales_inquiry"
  | "support_request"
  | "meeting_request"
  | "vendor_invoice"
  | "personal"
  | "requires_attention";

export interface EmailClassification {
  category: EmailCategory;
  confidence: number; // 0-1
  urgency: "low" | "medium" | "high";
  summary: string;
  suggestedAction: string;
  extractedData: Record<string, unknown>;
}

const anthropic = new Anthropic();

export async function classifyEmail(
  from: string,
  subject: string,
  body: string,
  myContext: string // Brief description of who you are and your role
): Promise<EmailClassification> {
  const response = await anthropic.messages.create({
    model: "claude-haiku-4-20250514",
    max_tokens: 512,
    system: `You are an email classifier. Analyze the email and return a JSON classification.

Categories:
- newsletter: Marketing emails, subscriptions, automated digests
- sales_inquiry: Someone trying to sell something to us
- support_request: Customer or user needing help
- meeting_request: Someone requesting a meeting or call
- vendor_invoice: Bill or invoice that needs processing
- personal: Personal or social communication
- requires_attention: Important email requiring human judgment

Return valid JSON only. No explanation.`,
    messages: [
      {
        role: "user",
        content: `My context: ${myContext}

Email from: ${from}
Subject: ${subject}
Body: ${body.slice(0, 2000)}`,
      },
    ],
  });

  const text = response.content[0].type === "text" ? response.content[0].text : "{}";

  try {
    return JSON.parse(text);
  } catch {
    return {
      category: "requires_attention",
      confidence: 0.3,
      urgency: "medium",
      summary: "Could not classify email automatically",
      suggestedAction: "Manual review required",
      extractedData: {},
    };
  }
}

// response-generator.ts
import Anthropic from "@anthropic-ai/sdk";
import { EmailClassification } from "./email-classifier.js";

const anthropic = new Anthropic();

export async function generateAutoResponse(
  emailContent: { from: string; subject: string; body: string },
  classification: EmailClassification,
  myInfo: {
    name: string;
    role: string;
    calendarLink: string;
    supportUrl: string;
  }
): Promise<string | null> {
  // Only auto-respond to these categories
  const autoRespondCategories = ["meeting_request", "sales_inquiry", "support_request"];

  if (!autoRespondCategories.includes(classification.category)) {
    return null;
  }

  if (classification.confidence < 0.8) {
    // Too uncertain to auto-respond
    return null;
  }

  const templates: Record<string, string> = {
    meeting_request: `Generate a polite, brief reply to this meeting request.
      - Thank them for reaching out
      - Direct them to my calendar: ${myInfo.calendarLink}
      - Keep it under 50 words
      - Sign as ${myInfo.name}`,

    sales_inquiry: `Generate a polite decline to this sales email.
      - Be warm but firm
      - Don't apologize
      - Keep it under 40 words
      - Don't offer to follow up
      - Sign as ${myInfo.name}`,

    support_request: `Generate a helpful first-response to this support request.
      - Acknowledge their issue
      - Direct them to: ${myInfo.supportUrl}
      - If the question seems simple, attempt to answer it briefly
      - Keep it under 100 words
      - Sign as ${myInfo.name}, ${myInfo.role}`,
  };

  const prompt = templates[classification.category];
  if (!prompt) return null;

  const response = await anthropic.messages.create({
    model: "claude-sonnet-4-20250514",
    max_tokens: 300,
    messages: [
      {
        role: "user",
        content: `Original email:\nFrom: ${emailContent.from}\nSubject: ${emailContent.subject}\nBody: ${emailContent.body.slice(0, 1000)}\n\nTask: ${prompt}`,
      },
    ],
  });

  return response.content[0].type === "text" ? response.content[0].text : null;
}

// api-server.ts
import express from "express";
import { classifyEmail } from "./email-classifier.js";

const app = express();
app.use(express.json());

app.post("/classify", async (req, res) => {
  const { from, subject, body, context } = req.body;

  try {
    const classification = await classifyEmail(from, subject, body, context);
    res.json(classification);
  } catch (error) {
    res.status(500).json({ error: String(error) });
  }
});

app.listen(3001, () => console.log("Email classifier running on port 3001"));

// digest-generator.ts
import Anthropic from "@anthropic-ai/sdk";

interface NewsletterItem {
  from: string;
  subject: string;
  summary: string;
  date: Date;
}

export async function generateWeeklyDigest(
  newsletters: NewsletterItem[]
): Promise<string> {
  const anthropic = new Anthropic();

  const response = await anthropic.messages.create({
    model: "claude-sonnet-4-20250514",
    max_tokens: 2048,
    messages: [
      {
        role: "user",
        content: `Create a concise weekly newsletter digest from these ${newsletters.length} items.

Group by topic/source. Lead with the most valuable information. 
Be opinionated about what's worth my time. Skip obvious filler.
Format as HTML for email. Keep total under 500 words.

Newsletters:
${newsletters.map(n => `FROM: ${n.from}\nSUBJECT: ${n.subject}\nSUMMARY: ${n.summary}`).join("\n\n")}`,
      },
    ],
  });

  return response.content[0].type === "text" ? response.content[0].text : "<p>Error generating digest</p>";
}