Building an Intelligent Email Triage System with n8n and AI

The Email Overload Crisis

We’re drowning in email. According to McKinsey research, the average professional spends 28% of their workweek managing email—that’s over 13 hours per week just reading and responding to messages¹. With 38.4% of workers receiving 6-10 emails daily and many juggling 11+ different communication tools², it’s no wonder that 80% of global workers report experiencing information overload³.

This constant barrage of digital communication isn’t just annoying—it’s actively harming productivity and well-being. Every email notification disrupts focus, and the cognitive load of constantly triaging messages leads to decision fatigue and burnout.

Want to skip to the code? Check out the n8n-workflows repository on GitHub for the complete workflow.

Enter AI-Powered Email Automation

What if we could leverage AI to automatically categorize emails based on their actionability, learn from our decisions over time, and only surface the messages that truly need our attention? That’s exactly what I built using n8n, OpenAI’s latest models, and a vector database for continuous learning.

In this post, I’ll walk you through building an intelligent email triage system that has reduced my email processing time by 60% while ensuring zero important messages slip through the cracks.

Prerequisites: This guide assumes you have n8n deployed and running. If you need help setting up n8n, check out my comprehensive guide on Deploying n8n on AWS EKS for a production-ready setup.

The Intelligent Email Triage Workflow

My Email Analysis workflow is a sophisticated n8n automation that acts as an intelligent email assistant. Here’s what it does:

Core Features

1. Automatic Email Fetching: Connects to Gmail via OAuth2 to retrieve unread messages in batches
2. AI-Powered Analysis: Uses OpenAI’s o3-mini model to analyze each email’s content and determine action likelihood
3. Smart Categorization:
   • High Priority (>95% confidence): Automatically flagged as important and user notified
   • Low Priority (<20% confidence): Can be safely discarded with optional 10-second override
   • Human Review (20-95%): Requires manual decision via Slack
4. Continuous Learning: Stores human feedback in a PostgreSQL vector database to improve future predictions
5. Flexible Execution Modes: Supports both automatic and manual review modes
6. Gmail Integration: Applies appropriate labels and marks emails as processed

Workflow Overview

The complete intelligent email triage workflow with 11 distinct processing sections

Detailed Workflow Architecture

Let’s explore each section of the workflow in detail:

1️⃣ Email Intake Section

The workflow begins with flexible execution settings:

// Execution Settings node allows you to configure:
{
  "automatic": true,        // Run in automatic mode (flag for later review)
  "notify_on_discard": false // Send Slack notifications for auto-discarded emails
}

This section:

• Supports manual triggering or scheduled execution
• Fetches up to 500 unread Gmail messages per batch
• Processes emails one by one to ensure data persistence even on errors

2️⃣ Pre-Processing Section

Before AI analysis, the workflow:

• Checks if the email has already been processed using Gmail labels
• Extracts and formats email content into an AI-optimized prompt
• Handles parsing errors gracefully

The Python code extracts key information:

def build_email_prompt(email: dict) -> str:
    """
    Extract the most relevant fields and return an AI-friendly prompt.
    """
    return {
        "subject": email.subject,
        "from": email.from,
        "to": email.to,
        "cc": email.cc,
        "date": email.date,
        "body": email.text or strip_html(email.html),
        "urls": extract_urls(email.body)
    }

3️⃣ AI Learning Layer

This is where the magic of continuous learning happens:

1. Vector Search: Queries PostgreSQL with pgvector to find similar past emails
2. Semantic Embeddings: Uses OpenAI’s text-embedding-3-large model (3072 dimensions)
3. Context Retrieval: Loads top 3 most similar emails with their human feedback
4. Relevance Filtering: Only includes examples with similarity score < 0.3

4️⃣ AI Analysis Engine

The heart of the system uses OpenAI’s o3-mini model with structured output:

{
  "summary": {
    "email_id": "unique_id",
    "action_likelihood": 0.745,
    "justification": "Meeting invite requires RSVP",
    "content_summary_and_interpretation": "John from Sales wants you to confirm attendance..."
  },
  "tasks": [
    {
      "task_description": "RSVP to quarterly review meeting",
      "due_date": "2025-02-10T15:00:00Z",
      "priority": 0.800,
      "context": {
        "subject": "Q1 Review Meeting",
        "sender": "John Smith <john@company.com>"
      }
    }
  ]
}

The system prompt is carefully crafted to produce consistent, actionable output with precise probability scores.

5️⃣ Smart Router

The decision router implements intelligent thresholds:

• 🔴 >95% confidence: Automatic action required
• 🟡 20-95% confidence: Human judgment needed
• 🟢 <20% confidence: Safe to auto-discard

6️⃣ High Priority Lane

For emails with >95% action likelihood:

1. Sends immediate Slack notification with email details
2. Flags email with “Actionable” label in Gmail
3. Marks as read and moves to next email

This handles ~15% of email volume based on my usage patterns.

7️⃣ Human Review Lane

The most sophisticated section, handling ~25% of emails:

In Automatic Mode:

• Flags email for later batch review
• Continues processing without interruption

In Manual Mode:

• Sends detailed Slack message with custom form
• Waits for human decision (Yes/No/Skip)
• Captures reasoning for learning

8️⃣ Low Priority Lane

Handles ~60% of email volume:

With Notifications Enabled:

• Sends “will auto-discard in 10 seconds” message
• Allows override with disapprove button
• Times out after 0.08 minutes (5 seconds)

Without Notifications:

• Directly flags as discarded
• Marks as read

9️⃣ Learning Feedback Loop

This section enables continuous improvement:

1. Formats Feedback: Combines human decision with original email
2. Creates Embeddings: Generates 3072-dimensional vectors
3. Stores in Database: PostgreSQL with pgvector extension
4. Routes Decision: Directs to appropriate final action

The feedback format:

---- HUMAN FEEDBACK ---
Does this action require human feedback?
Yes/No

Why or why not?
[Human reasoning]

---------  EMAIL --------
[Original email content]

🔟 Final Actions

All paths converge here for consistent handling:

• ✓ Important → Flag + notify
• ✓ Discarded → Flag + archive
• ✓ All → Mark as read
• ✓ Loop → Process next email

⚠️ Error Handling

Robust error handling ensures workflow continuity:

• Catches API failures and parsing errors
• Flags problematic emails for manual review
• Continues to next email without interruption
• Prevents cascade failures

Implementation Guide

Prerequisites

1. n8n Instance: Follow my n8n on AWS EKS guide for production deployment
2. Gmail OAuth2: Set up application credentials in Google Cloud Console
3. OpenAI API Key: For o3-mini model and embeddings
4. PostgreSQL with pgvector: For storing feedback vectors
5. Slack Workspace: For notifications and human review

Step 1: Database Setup

Create your vector storage table:

-- Enable pgvector extension
CREATE EXTENSION IF NOT EXISTS vector;

-- Create feedback storage table
CREATE TABLE email_vectors_reformatted (
  id SERIAL PRIMARY KEY,
  content TEXT,
  embedding vector(3072),
  metadata JSONB,
  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

-- Create index for similarity search
CREATE INDEX ON email_vectors_reformatted 
USING ivfflat (embedding vector_cosine_ops);

Step 2: Gmail Label Configuration

Create these labels in Gmail and update the workflow with their IDs:

1. n8n/Processed - Already analyzed emails
2. n8n/Actionable - High priority emails
3. n8n/Review - Needs human review
4. n8n/Discarded - Low priority emails
5. n8n/ManuallyDiscarded - Human confirmed no action
6. n8n/Error - Processing failures

Note: After creating labels, use Gmail API to get their IDs and update the “Check If Already Processed” node with the correct values.

Step 3: Import and Configure Workflow

1. Download the Intelligent Email Triage workflow JSON
2. Import into your n8n instance
3. Configure credentials:
   • Gmail OAuth2
   • OpenAI API (with o3-mini access)
   • PostgreSQL connection
   • Slack app

Step 4: Customize Settings

Adjust these key parameters:

// In "Execution Settings" node
{
  "automatic": true,        // Start in automatic mode
  "notify_on_discard": false // Enable once comfortable
}

// In "AI Task List Builder" node
{
  "model": "o3-mini",
  "reasoningEffort": "low" // Balance cost vs accuracy
}

// In decision thresholds
{
  "high_priority": 0.95,   // Adjust based on your needs
  "low_priority": 0.20     // Lower = more aggressive filtering
}

Real-World Results

After two weeks of continuous use:

Metrics

• Email Processing Time: Reduced from 2+ hours to 45 minutes daily (60% reduction)
• Accuracy: 85% correct categorization after initial training period
• False Positives: <5% (important emails marked as low priority)
• False Negatives: <2% (unimportant emails marked as high priority)

Volume Distribution

• High Priority (auto-action): ~15%
• Human Review Required: ~25%
• Auto-discarded: ~60%

Cost Analysis

• OpenAI API: ~$8/month (processing 100-150 emails daily)
• PostgreSQL Storage: Minimal (vector embeddings are compact)
• Total operational cost: <$10/month

Advanced Optimizations

1. Batch Processing for Scale

For high-volume email accounts, modify the workflow to:

• Process emails in larger batches
• Implement parallel processing for non-dependent operations
• Use Redis for queue management

2. Custom Training Data

Improve accuracy by:

• Pre-loading historical email decisions
• Creating domain-specific embeddings
• Fine-tuning prompts for your communication style

3. Multi-Account Support

Extend the workflow to handle multiple email accounts:

• Add account selector in execution settings
• Store account-specific feedback separately
• Implement per-account thresholds

4. Integration Extensions

Enhance functionality with:

• Calendar integration for meeting-related emails
• Task management system connections
• CRM updates for customer communications

Troubleshooting

Common Issues and Solutions

Gmail API Rate Limits

• Implement exponential backoff
• Process smaller batches during peak hours

Vector Search Performance

• Optimize PostgreSQL settings for vector operations
• Implement periodic embedding cleanup

Slack Notification Delays

• Check webhook configuration
• Monitor Slack API status

High False Positive Rate

• Adjust decision thresholds
• Review and correct mislabeled training data
• Increase context examples from 3 to 5

Conclusion

Building an intelligent email triage system with n8n demonstrates the power of combining workflow automation with AI and continuous learning. The system not only saves significant time but also improves accuracy through feedback loops.

Key takeaways:

• Start Simple: Begin with basic categorization and add learning later
• Human-in-the-Loop: Critical for training and edge cases
• Continuous Improvement: The system gets smarter with every decision
• Cost-Effective: Powerful automation for less than $10/month

The beauty of this approach is its adaptability. As your communication patterns change, the system evolves with you, ensuring consistent productivity gains over time.

Next Steps

1. Deploy n8n using my AWS EKS guide
2. Import and configure the email triage workflow
3. Start with manual mode to build training data
4. Gradually transition to automatic mode as accuracy improves

Ready to reclaim your inbox? The complete workflow is available on GitHub along with setup scripts and additional documentation.

References

Additional Resources

• Download the Intelligent Email Triage workflow
• n8n AI Workflow Automation Guide
• OpenAI o3-mini Documentation
• pgvector PostgreSQL Extension
• n8n Community Forum - Get help and share improvements

Related Posts

• Deploying n8n on AWS EKS: A Production-Ready Guide
• Coming Soon: AI-Powered JIRA Ticket Quality Gatekeeper
• Coming Soon: Automated Release Notes for Modern DevOps