Reply to your emails with a local AI (LLM private)

#The principle: draft, never send automatically

The goal here is not to have a robot reply on your behalf, but to reduce the time spent drafting repetitive or standard responses: acknowledgments, replies to frequently asked questions, and rewrites of an overly informal draft. The LLM generates text, you read it, correct it if needed, and decide whether to send it. No step in this process should be automated through sending without human validation.

#The realistic architecture

A local email assistant architecture consists of three elements: your usual mail client (Thunderbird, or any client that accepts an extension), an extension or module that can call a language model API, and a model running on your machine, served by Ollama at its default local address (127.0.0.1, port 11434). Email continues to be handled normally by your client (IMAP receiving, SMTP sending): only the draft text passes to the local model for generation, never to a third-party service.

#An example of an existing extension

ThunderAI is a Thunderbird extension that integrates AI directly into email, with explicit support for Ollama in addition to cloud providers. Its documentation states that it runs entirely locally (model, context size, temperature, reasoning mode), allowing you to keep everything on the machine instead of depending on an external server.

In practical terms, a function like this can generate a draft reply from the selected email using a simple prompt, an advanced prompt, or a custom instruction you write. The generated text opens in the mail client’s usual compose window: nothing is sent unless you go through that window.

#Other extensions of the same type

ThunderAI is not the only option: the ecosystem of AI-focused Thunderbird extensions has grown, with slightly different approaches. thunderbird-ai (Project516) bets on an “AI review” button that rereads a draft while you are writing it to check its tone, typos, and especially attachments mentioned in the text but forgotten when sending — a practical check that ThunderAI does not explicitly offer. Quill, meanwhile, provides writing assistance connected to Ollama, OpenAI, or Claude, your choice.

The documented common thread among these extensions: the email content is sent to the model only when the user explicitly takes an action, never in the background. thunderbird-ai states this unambiguously in its documentation, which is worth checking for any extension before installing it, whether local or not: an extension that continuously analyzed your emails, even with a local model, would change the nature of the privacy commitment compared with on-demand generation.

#What “local” really guarantees

Running the model on your machine means the content of the email processed by the model does not pass through a third-party service to generate the draft. This does not change how the email itself is transported: receiving and sending still use standard protocols (IMAP, SMTP) to your mail server, whether local or not. “Local AI” secures the text-generation step, not the entire email chain.

#Set up the assistant

1. 01
   Install Ollama and a suitable model

   A 7 to 8B model in Q4 quantization works for writing routine emails; a larger model helps with more nuanced responses if your machine can handle it.
2. 02
   Install a compatible extension

   Verify that the chosen extension explicitly offers a Ollama mode or a compatible local OpenAI server, not just cloud providers.
3. 03
   Configure the local address

   Point the extension to the default address of the Ollama server, typically 127.0.0.1 on port 11434.
4. 04
   Test it on a non-sensitive email

   Generate a first draft for a low-stakes email to validate the tone and relevance before using it for important correspondence.

#Why human review is still mandatory

A model generates plausible text, not necessarily accurate text. In a professional email, a tone mistake, incorrect information slipped into a rephrasing, or an answer that doesn’t address the actual question are real risks, even with a good model. Proofreading isn’t excessive caution: it’s the only step that ensures what’s sent in your name matches what you actually meant to say.

Verify the cited facts

A model may rephrase a date, amount, or commitment slightly differently from the original: compare it with the source email before sending.

Check the tone

A generated draft may be too formal, too casual, or poorly calibrated for your usual audience.

Verify recipients

The model does not know the relational context: you must decide whether the proposed wording is appropriate for this specific person.

Verify the announced attachments

If the draft mentions an attached document, confirm that it is actually attached before sending: the model writes the text, not the attachment itself.

This list is not a formality: it reflects the errors most frequently reported by users of this type of tool, not theoretical risks. A draft generated in a few seconds creates an impression of reliability that can make you review it more quickly than text you wrote yourself, when the exact opposite is what protects you: generation speed eliminates no verification step; it simply makes review more time-efficient overall.

#One step further: task sorting and extraction

Beyond the occasional draft generated in the email client, community projects go further: AI-Email-Agent is a local-first agent that connects to your mailbox via IMAP, categorizes messages, and extracts actionable tasks through Ollama (using the llama3 model), while keeping all processing on the machine (Ollama and a local SQLite database), with no dependency on a third-party cloud service for this part.

The structural difference from the assistant described above is that this type of agent handles more automated steps (sorting, categorization) than simply generating a draft on request. That's why these projects document a human validation gate (human-in-the-loop) before any action, rather than letting automation run all the way through without oversight. The principle remains the same as for a simple writing assistant: the further automation advances through the workflow (sorting, tasks, response), the more explicit human validation becomes essential, not optional.

#Toward native email client integration

Beyond third-party extensions, Mozilla has submitted a proposal for an assistant integrated directly into Thunderbird, aimed at reducing time spent on email and the cognitive load of sorting and drafting, without sacrificing privacy according to the proposal's terms. This type of initiative aligns with current extensions: assisted drafting, tone changes, and draft rewriting, with the source email and conversation thread as optional rather than mandatory context.

Whether the assistant is a third-party extension or an upcoming native feature, the principle remains the same: the benefit lies in drafting time, not in delegating the decision to send. An email client that one day offered automatic sending without confirmation would represent a fundamental change in the tool, not a simple improvement to the writing assistant described throughout this guide.

#What it does not replace

A local assistant helps start a response; it doesn’t manage an entire inbox. Automatic sorting, prioritizing urgent messages, or sending without supervision are automations of a different order, raising different reliability and accountability questions from simple drafting assistance. This guide deliberately remains focused on reviewed drafts: for routine professional correspondence, that is currently the best balance between real time savings and risk.

• Automate workflows with n8n and Ollama
• Install an LLM locally, step by step
• The best free local AI in 2026
• Privacy checklist for local AI use
• Source: ThunderAI extension (Thunderbird + Ollama)
• Source: Mozilla proposal for an assistant integrated into Thunderbird
• Source: official Ollama documentation (default local address)
• Source: thunderbird-ai extension (AI review, local Ollama/llama.cpp)
• Source: AI-Email-Agent, a local-first agent with human validation