AI Email Automation Examples

A system that reads incoming emails, classifies them by category (sales enquiry, support request, billing issue, spam), assesses urgency, and routes to the appropriate team or queue with priority labels.

// Email triage system
async function triageEmail(email) {
  const classification = await llm.chat({
    messages: [{
      role: "system",
      content: "Classify this email. Return JSON: { category, urgency (1-5), department, suggestedAction }"
    }, { role: "user", content: `From: ${email.from}\nSubject: ${email.subject}\nBody: ${email.body}` }],
    responseFormat: { type: "json_object" }
  });

  await routeEmail(email.id, {
    queue: classification.department,
    priority: classification.urgency,
    labels: [classification.category],
    suggestedAction: classification.suggestedAction,
  });

  return classification;
}

Generates draft responses to customer support emails by matching the query to the knowledge base, personalising the response with customer context from the CRM, and queuing it for agent review before sending.

// Auto-draft support response
async function draftSupportResponse(email) {
  const customer = await crm.getCustomer(email.from);
  const relevantArticles = await knowledgeBase.search(email.body, { topK: 3 });

  const draft = await llm.chat({
    messages: [{
      role: "system",
      content: `Draft a support email response. Customer: ${customer.name}, plan: ${customer.plan}.
      Use the knowledge base articles for accuracy. Match our brand voice: friendly, professional, concise.`
    }, {
      role: "user",
      content: `Email: ${email.body}\n\nRelevant articles:\n${relevantArticles.map(a => a.content).join("\n")}`
    }]
  });

  await supportQueue.addDraft(email.id, { draft, sources: relevantArticles, confidence: draft.confidence });
}

Summarises long email threads into key points, decisions made, action items, and open questions. Particularly useful for joining conversations mid-thread or preparing for meetings related to email discussions.

// Email thread summarisation
async function summariseThread(thread) {
  const summary = await llm.chat({
    messages: [{
      role: "system",
      content: "Summarise this email thread. Include: key points, decisions made, action items (with owners), and unresolved questions."
    }, { role: "user", content: thread.messages.map(m => "From: " + m.from + " (" + m.date + ")\n" + m.body).join("\n---\n") }],
    responseFormat: { type: "json_object" }
  });

  return {
    keyPoints: summary.keyPoints,
    decisions: summary.decisions,
    actionItems: summary.actionItems,
    openQuestions: summary.openQuestions,
    participantCount: new Set(thread.messages.map(m => m.from)).size,
  };
}

Generates personalised multi-touch email sequences for prospects based on their company profile, recent news, and engagement history. Adapts tone and messaging based on the prospect's industry and seniority level.

// Sales sequence generator
async function generateSequence(prospect) {
  const context = {
    company: await enrichCompany(prospect.company),
    recentNews: await getRecentNews(prospect.company),
    industry: prospect.industry,
    seniority: prospect.title,
    previousEngagement: await getEngagementHistory(prospect.email),
  };

  const sequence = await llm.chat({
    messages: [{
      role: "system",
      content: `Create a 4-email sequence. Each email should: be under 150 words, have a clear CTA, reference something specific to their company. Vary the angle for each email.`
    }, { role: "user", content: JSON.stringify(context) }]
  });

  return sequence.emails.map((email, i) => ({
    ...email,
    sendDelay: [0, 3, 7, 14][i], // Days after previous
  }));
}

Scans outgoing emails for compliance risks: sensitive data exposure, regulatory violations, inappropriate content, or policy breaches. Flags risky emails for review before sending and logs all decisions for audit trails.

// Compliance email monitoring
async function scanOutgoingEmail(email) {
  const risks = await llm.chat({
    messages: [{
      role: "system",
      content: `Analyse this email for compliance risks:
      - PII or sensitive data in body/attachments
      - Regulatory violations (financial advice without disclaimers)
      - Policy violations (external sharing of internal data)
      Return: { risks: [{ type, severity, excerpt }], overallRisk: "low|medium|high" }`
    }, { role: "user", content: `To: ${email.to}\nSubject: ${email.subject}\nBody: ${email.body}` }]
  });

  if (risks.overallRisk !== "low") {
    await holdForReview(email.id, risks);
    await auditLog.record({ emailId: email.id, risks, timestamp: new Date() });
  }

  return { send: risks.overallRisk === "low", risks };
}