Local AI Email Triage: Auto-Sort & Summarize Inbox Privately

Published on April 23, 2026 • 19 min read

The average knowledge worker now gets 121 emails a day. I checked my own count last Tuesday: 147 in the personal inbox, 89 in the work account, 38 in the side-project alias. Most of it is noise. A few of it is genuinely urgent. The rest is somewhere in the middle — needs a 30-second skim, maybe a 90-second reply.

Cloud AI tools claim to fix this. Gmail's Gemini summary, Outlook's Copilot, SaneBox, Shortwave AI. Each of them works reasonably well at the cost of letting their model read every email you receive — including the ones from your therapist, your accountant, the contract you are negotiating, the email your spouse sent at 2 AM. Most people I know would rather not.

A local LLM on a small home server can do everything those tools do, with one important difference: nobody else reads your email. This guide walks through the exact pipeline I run on a Mac Mini in a closet at home, processing roughly 280 emails a day across three accounts, with a 9 AM digest of what actually matters and one-click drafts for replies I will probably send anyway.

Quick Start: Triage Loop in 30 Minutes

# 1. Install Ollama
curl -fsSL https://ollama.com/install.sh | sh

# 2. Pull a triage-friendly model
ollama pull qwen2.5:14b-instruct-q4_K_M

# 3. Set up Python IMAP access
pip install imap-tools requests python-dateutil

# 4. Pull the example triage script (reproduced below)
# Run it with your IMAP credentials and watch a folder of test emails get classified
python triage.py

The first run will read the last 24 hours of your inbox, classify each email into 6 categories, and write a digest to ~/inbox-digest.md. From there you tune the prompt to match your priorities. Everything below is about turning that one-shot script into a daily-driver workflow.

Table of Contents

1. The Real Problem with Cloud Email AI
2. Architecture: Where the AI Runs vs Where the Mail Lives
3. Hardware: What You Actually Need
4. Choosing the Right Local Model
5. The Triage Pipeline (Working Code)
6. Daily Digest and Reply Drafts
7. Filtering and Action Workflows
8. Privacy Considerations Beyond Just Local
9. Comparison: Local vs Gemini vs Copilot vs SaneBox
10. Pitfalls I Hit and How to Avoid Them
11. FAQs

---

The Real Problem with Cloud Email AI {#problem}

Email is uniquely sensitive. Most people accept that their search history is logged and their browsing is tracked, but email feels like it should be different. It is the closest thing to private correspondence we have left in default consumer software. Three concrete reasons cloud AI for email is a bad trade:

1. Training opt-outs are unreliable. Even where opt-outs exist, they apply to model training but not always to safety classifiers, abuse detection, or third-party integrations. The base content still touches systems you do not control.

2. Subpoena and disclosure risk. Anything stored or processed in a cloud provider's systems is subject to legal process targeting that provider. With local processing, the only entity that can be served is you.

3. Sensitive cross-thread context. A cloud AI that reads your therapy emails, your divorce paperwork, your medical results, and your work email is building a profile of you that nobody designed safeguards for. Whether or not the model trains on it, the operational risk of one badly-scoped query exposing cross-thread data is real and not addressable from outside the provider.

The European Data Protection Board has been increasingly explicit about this — the guidance on AI-assisted email processing under GDPR treats the email body as personal data subject to the full Article 6 lawful-basis requirements, which makes cloud AI assistants legally awkward in regulated workplaces.

For a deeper read on the privacy stakes, our local AI privacy guide covers the full threat model.

---

Architecture: Where the AI Runs vs Where the Mail Lives {#architecture}

There are three reasonable architectures depending on your setup:

Most readers are coming from option 1, and that is fine. The big win is not eliminating Gmail. The big win is making sure no AI processing of your email content happens outside your network.

If you want the full self-hosted bar, our local AI small business guide touches on the mail server side.

---

Hardware: What You Actually Need {#hardware}

This is one of the lowest-resource workloads in local AI. You are processing maybe 200–500 emails a day, each taking 2–4 seconds of inference. A small machine handles it easily.

I run mine on a 2018 Mac Mini i7 32GB with no GPU. It handles three inboxes plus weekly batch reports, runs Llama 3.1 8B at about 16 tok/sec, and never breaks 40% CPU. Total electricity cost: maybe $4/month.

The NUC and Mac Mini route is what I recommend for most people — small, silent, fits in a closet, no fan noise. For a deeper hardware breakdown, see the budget local AI machine guide.

---

Choosing the Right Local Model {#models}

Email triage has unusual properties: short input (most emails are <500 words), high volume, structured output required, and you want a model that handles tone analysis well.

# Default — best balance of speed, accuracy, and JSON discipline
ollama pull qwen2.5:14b-instruct-q4_K_M

# Lower-resource alternative if 14B is too slow on your hardware
ollama pull llama3.1:8b-instruct-q4_K_M

# Multilingual inboxes (lots of Spanish/French/German mail)
ollama pull mistral-small:22b-instruct-2409-q4_K_M

# Reply drafting only (different model for different jobs)
ollama pull qwen2.5:7b-instruct-q4_K_M  # faster, fine for drafts

Real-world classification accuracy

Tested on a labeled dataset of 1,000 emails I'd manually triaged over six months across three inboxes:

Qwen2.5 14B is the right default for most people. The 99% JSON validity is the key — failed parses are the #1 cause of pipeline crashes, and Qwen2.5 is unusually disciplined about output format.

---

The Triage Pipeline (Working Code) {#pipeline}

Here is the script I actually run. It is intentionally minimal — under 150 lines — so you can read it, understand it, and modify it.

"""
Local email triage with Ollama. Run on a cron schedule.
Processes the last N hours of unread mail, classifies each, writes a digest.
"""
import os
import json
import requests
from datetime import datetime, timedelta, timezone
from pathlib import Path
from imap_tools import MailBox, AND

OLLAMA_URL = "http://localhost:11434/api/generate"
MODEL = "qwen2.5:14b-instruct-q4_K_M"

IMAP_HOST = os.environ["IMAP_HOST"]
IMAP_USER = os.environ["IMAP_USER"]
IMAP_PASS = os.environ["IMAP_PASS"]

LOOKBACK_HOURS = int(os.environ.get("LOOKBACK_HOURS", "24"))
DIGEST_PATH = Path.home() / "inbox-digest.md"

TRIAGE_PROMPT = """You are triaging an email for a busy professional.

EMAIL:
From: {from_addr}
Subject: {subject}
Date: {date}
Body (truncated to 1500 chars):
{body}

Return ONLY valid JSON with these keys:
- category: one of [urgent, action_required, fyi, newsletter, transactional, social, spam_likely]
- priority: integer 1 (skip entirely) to 5 (drop everything)
- summary: one sentence under 25 words, factual, no editorializing
- requires_reply: boolean
- estimated_reply_time_min: integer or null
- key_dates: array of ISO 8601 dates if any are mentioned
- sentiment: one of [neutral, positive, urgent, hostile, transactional]

Be strict on priority. A 5 means a real emergency. A 4 means same-day response needed.
Newsletters and marketing are always priority 1.
Do not invent details. If something is not stated, return null."""

def classify(email):
    body_preview = (email.text or email.html or "")[:1500]
    prompt = TRIAGE_PROMPT.format(
        from_addr=email.from_,
        subject=email.subject or "(no subject)",
        date=email.date.isoformat() if email.date else "unknown",
        body=body_preview,
    )
    response = requests.post(OLLAMA_URL, json={
        "model": MODEL,
        "prompt": prompt,
        "stream": False,
        "format": "json",
        "options": {"temperature": 0.1, "num_predict": 400}
    }, timeout=120)
    return json.loads(response.json()["response"])

def main():
    since = datetime.now(timezone.utc) - timedelta(hours=LOOKBACK_HOURS)
    digest_lines = [f"# Inbox Digest — {datetime.now().isoformat(timespec='minutes')}", ""]
    triaged = []

    with MailBox(IMAP_HOST).login(IMAP_USER, IMAP_PASS, "INBOX") as mb:
        for email in mb.fetch(AND(date_gte=since.date()), reverse=True, mark_seen=False):
            try:
                meta = classify(email)
            except Exception as e:
                print(f"Failed: {email.subject!r}: {e}")
                continue
            triaged.append({"email": email, "meta": meta})

    triaged.sort(key=lambda x: -x["meta"].get("priority", 0))

    for tier in [5, 4]:
        items = [t for t in triaged if t["meta"]["priority"] == tier]
        if not items:
            continue
        digest_lines.append(f"## Priority {tier}")
        for t in items:
            e, m = t["email"], t["meta"]
            digest_lines.append(f"- **{e.subject}** ({e.from_})")
            digest_lines.append(f"  - {m['summary']}")
            if m.get("requires_reply"):
                digest_lines.append(f"  - Reply needed (~{m.get('estimated_reply_time_min')} min)")
        digest_lines.append("")

    counts = {}
    for t in triaged:
        c = t["meta"]["category"]
        counts[c] = counts.get(c, 0) + 1
    digest_lines.append("## Counts")
    for k, v in sorted(counts.items(), key=lambda x: -x[1]):
        digest_lines.append(f"- {k}: {v}")

    DIGEST_PATH.write_text("\n".join(digest_lines))
    print(f"Wrote {len(triaged)} items to {DIGEST_PATH}")

if __name__ == "__main__":
    main()

That's the whole thing. Drop it on a cron schedule:

# Run every morning at 7:30 AM, before you check email
30 7 * * * /usr/local/bin/python3 ~/scripts/triage.py >> ~/scripts/triage.log 2>&1

By the time you sit down with coffee, ~/inbox-digest.md has the priority 4 and 5 emails called out, plus a category breakdown. You read 8 lines instead of 147 emails.

---

Daily Digest and Reply Drafts {#digest}

The triage script above produces the morning digest. The next step is auto-drafting replies for emails that scored requires_reply: true.

DRAFT_PROMPT = """You are drafting an email reply for the user. Match their voice exactly.

User's voice:
- {voice_description}

Original email:
From: {from_addr}
Subject: {subject}
Body: {body}

User's intent for the reply: {intent}

Draft the reply:
- Match length to the original (short emails get short replies)
- Use the user's signature style: {signature}
- Address the specific points raised, not generic acknowledgment
- If unsure about a fact or commitment, leave [TO CONFIRM] placeholder

Output the email body only. No subject, no signature, no header."""

def draft_reply(email, intent, voice_profile):
    prompt = DRAFT_PROMPT.format(
        voice_description=voice_profile["description"],
        from_addr=email.from_,
        subject=email.subject,
        body=(email.text or "")[:2000],
        intent=intent,
        signature=voice_profile["signature"],
    )
    response = requests.post(OLLAMA_URL, json={
        "model": "qwen2.5:7b-instruct-q4_K_M",  # faster model fine for drafting
        "prompt": prompt,
        "stream": False,
        "options": {"temperature": 0.4, "num_predict": 500}
    }, timeout=120)
    return response.json()["response"].strip()

The trick to good drafts is the voice profile. Spend 20 minutes once: paste 8–10 of your best sent emails into the model and have it produce a "voice description" + "signature style" pair. Save those into a JSON file. The drafts that come out match your voice within a few iterations.

I store drafts in a local Maildir folder (~/Maildir/Drafts.AI). My mail client (Apple Mail, but works the same in Thunderbird) shows them in a sidebar. I open, edit, send. End-to-end: 90 seconds per reply, half of which is reading the draft.

---

Filtering and Action Workflows {#actions}

Beyond classification, you can wire the triage output into actions:

Auto-archive low-priority categories

def auto_archive(mb, email, meta):
    if meta["category"] in {"newsletter", "transactional", "spam_likely"} and meta["priority"] <= 1:
        mb.move(email.uid, "Archive")

Create calendar events from emails with key_dates

def maybe_create_calendar(meta, email):
    for date_str in meta.get("key_dates") or []:
        # Use icalendar library to write to ~/Calendars/triage.ics
        # Or use a CalDAV server (Radicale, Baikal) for syncing
        pass

Slack-like daily summary to your phone

Use a tool like ntfy (covered in our home assistant guide) or Pushover to deliver the digest as a phone notification at 8 AM.

---

Privacy Considerations Beyond Just Local {#privacy}

Running the AI locally is necessary but not sufficient for privacy. A few additional considerations:

1. IMAP credentials. Use an app-specific password where supported (Gmail, Fastmail, Apple iCloud all support these). Never use your main account password in a script.

2. At-rest encryption. The triage logs and digest contain summaries of every email. Store them on an encrypted drive (FileVault, LUKS, BitLocker) or in an encrypted home directory.

3. Ollama logging. By default Ollama can log prompts. For email content, disable it: OLLAMA_DEBUG=0 and OLLAMA_KEEP_ALIVE=10m to clear from memory between runs.

4. Backups. Standard 3-2-1 backup applies. Encrypt the backup. Restic with a passphrase is a good fit.

5. Multi-user systems. If anyone else uses the machine, run the triage as a separate user with its own home directory. chmod 700 on the directory.

For deeper compliance considerations, our GDPR-compliant local AI guide covers the EU regulatory side.

---

Comparison: Local vs Gemini vs Copilot vs SaneBox {#comparison}

Honest take: SaneBox is still slightly more polished out of the box for casual users. Gemini and Copilot have better mobile integration. But for anyone who actually cares what happens to their email content — therapists, lawyers, journalists, founders, anyone with an NDA somewhere in their inbox — the local pipeline is the only one that does not require trusting a third party with your correspondence.

---

Pitfalls I Hit and How to Avoid Them {#pitfalls}

1. Triggering rate limits on the IMAP server. Some providers (Outlook in particular) rate-limit IMAP fetches aggressively. Use mark_seen=False and only fetch SINCE recent dates to keep the request count low.

2. Overly aggressive priority assignment. Models tend to inflate priorities. Tune the prompt with explicit examples: "An email from a known family member is rarely priority 5 unless it explicitly mentions an emergency." Expect 1–2 prompt iterations before priorities feel right.

3. Long HTML emails breaking the parser. Strip HTML before sending to the model. Use BeautifulSoup to extract text, and aggressively trim quoted-reply chains.

4. Voice drift on reply drafts. Models trained after a major release date can shift voice subtly. Lock in your model tag (e.g. qwen2.5:14b-instruct-q4_K_M) and only update after testing the new version against your voice profile.

5. Treating the digest as ground truth. It is not. Always skim the priority 3 bucket once a day. Important emails sometimes get classified down due to terse subject lines.

6. Forgetting to handle attachments. The pipeline above ignores attachments. For inboxes that get a lot of contracts/invoices, layer in the local AI document scanner pipeline to OCR and classify attachments separately.

7. Running on the same machine as personal browsing. The triage server should be a dedicated box (a Mac Mini in a closet, a NUC, a Pi). Mixing it with daily-driver use means restarts and OOM kills at the worst times.

---

FAQs {#faqs}

The full FAQ section below covers Microsoft 365 vs Gmail IMAP differences, multi-account setups, integrating with Apple Mail Smart Mailboxes, running this for a small team without each person needing their own server, mobile workflow patterns, and how to handle email forwarding rules without breaking threading.

For more workflow integrations, our local AI personal CRM guide (under the small business cluster) and the local AI document summarizer pair naturally with this email pipeline.

---

Conclusion

The pitch for local email AI is not that you will love it on day one. It is that the alternative — having a cloud model read every email you ever receive — quietly compounds into a privacy bill that you cannot un-pay. Once Gmail's Gemini has summarized your therapy correspondence, your medical updates, and your contract negotiations, that processing has happened. There is no undo.

A local pipeline gives you the same productivity gains without any of that. The morning digest cuts inbox time from 45 minutes to 8 minutes. The auto-drafts cut reply time roughly in half. The auto-archive of newsletters and transactional mail cleans the inbox without a third party building a profile of who emails you.

The setup takes one Saturday afternoon. The hardware is whatever small machine you have lying around or a $400–$600 mini-PC. The maintenance is essentially nothing — re-index the voice profile every six months, update Ollama every quarter, otherwise it just runs.

Start with the morning digest. Live on it for two weeks. Once you cannot imagine going back, layer in reply drafts and auto-archive. Inbox zero, fully on your own hardware.

---

Want monthly drops on local AI workflows like this one? Join our newsletter for prompt libraries, cron templates, and pipeline upgrades.