AI email assistants are everywhere, but most tools still feel like generic text generators bolted on top of your inbox.
What users actually complain about on Reddit and X is different: AI that ignores context, sounds too “GPT-ish”, is slow, or worse, sends something that feels passive‑aggressive to a manager or a customer.
ToneCraft addresses that exact pain point inside Thunderbird: instead of writing emails for you from scratch, it focuses on one critical capability—detecting unprofessional language in your outgoing messages and suggesting polite alternatives with AI before you hit send.
In this article you will see how to build a ToneCraft‑style Thunderbird extension that runs on Regolo’s GPU LLM endpoints, so you can keep data in Europe, avoid vendor lock‑in, and give users fast, privacy‑first tone checking and rewriting.
Why AI tone checkers matter in 2026
On X and Reddit, conversations about AI email tools repeat a few themes: people are overwhelmed by email volume, worry about sounding rude or “too casual”, and do not fully trust AI to send emails without supervision.
Sales and support teams, in particular, care about tools that understand the entire thread, preserve intent, and adapt to their brand voice rather than generating “generic AI corporate speak”.
Common pain points that ToneCraft‑style tools can solve:
- Accidental rudeness: phrases that sound fine in chat but are risky in email (“WTF”, “as I already said”, “obviously”).
- Hierarchy‑aware tone: what you send to a peer is not what you send to a VP or a customer; AI needs hierarchy‑aware tone control.
- Context length: long threads get truncated or misunderstood by lightweight extensions, leading to off‑tone replies.
- Privacy concerns: many users avoid browser extensions because they do not trust where their email content is going.
ToneCraft is designed to sit right inside Thunderbird’s composer, detect risky language in real time, and let the user accept or tweak the AI suggestion—never silently sending on its own.
With Regolo as the LLM backend, you can keep email content in European GPU clusters with strict data privacy and no long‑term storage while still benefiting from high‑end NVIDIA hardware for low‑latency inference.
What ToneCraft does inside Thunderbird
From the official extension listing, ToneCraft is a Thunderbird add‑on in the “Message Composition” category that “detects (and blocks) unprofessional language in outgoing emails and suggests polite alternatives with AI.”
Practically, that breaks down into a few core behaviors:
- Hook into the compose window to read the current draft text before send.
- Run text through an LLM prompt that classifies tone and rewrites questionable segments.
- Highlight risky phrases inline and show a suggested rewrite in a side panel or popup.
- Optionally block sending when a “hard rule” is triggered (slurs, profanity, escalatory language), unless the user explicitly overrides.
Under the hood, ToneCraft is a Thunderbird MailExtension, similar to other AI‑powered add‑ons like ThunderAI or AI Mail Support, which also integrate ChatGPT, Claude, Gemini, Mistral, or local Ollama models.
Where ToneCraft is opinionated is in its single problem focus (email tone), which makes it easier to design safe prompts and predictable UX than “do everything” AI assistants.
Architecture: Thunderbird extension + Regolo GPU LLM
A production‑grade ToneCraft implementation can be split into three layers:
- Thunderbird front‑end (MailExtension)
- Listens to compose events.
- Extracts plain text from the email body and metadata (subject, sender/recipient).
- Calls a small backend or directly calls Regolo’s LLM endpoint via HTTPS.
- Backend (optional but recommended)
- Hides Regolo API keys from the client.
- Applies rate limiting, logging (without storing raw email content), and extra safety filters.
- Can add organization‑specific policies (e.g., “never use legal language X”, “avoid certain phrases”).
- Regolo LLM API
- Deployed on European GPU clusters (NVIDIA H100/A100/L40S style hardware).
- Supports multiple foundation models (e.g., general‑purpose chat models and smaller low‑latency ones).
- Enforced zero data retention and data‑privacy‑first policies by design.
Below is a minimal example of the data flow:
- User writes an email in Thunderbird.
- On
beforeSendor on button click (“Check tone”), the extension gathers the current draft. - The extension POSTs a request to your backend
/tonecraft/rewritewith the email text, recipients, and tone target. - The backend calls Regolo’s
/v1/chat/completions(or similar) with a specialized “tone rewrite” prompt. - Regolo returns a JSON structure with
analysis(what is unprofessional) andrewrite(suggested email). - The extension displays suggestions inline and lets the user apply them.
Implementing the Thunderbird MailExtension
ToneCraft can be built as a standard MailExtension, similar to existing AI add‑ons like ThunderAI and AI Mail Support.
Thunderbird supports APIs for message composition and allows add‑ons to modify or block sends under user consent.
Manifest skeleton
{
"manifest_version": 2,
"name": "ToneCraft",
"version": "0.1.0",
"description": "Detects unprofessional email tone and suggests polite alternatives with AI.",
"applications": {
"gecko": {
"id": "tonecraft@example.com",
"strict_min_version": "128.0"
}
},
"permissions": [
"compose",
"messagesRead",
"accountsRead",
"storage",
"notifications"
],
"background": {
"scripts": ["background.js"]
},
"compose_action": {
"default_title": "Check tone with ToneCraft",
"default_popup": "popup.html"
}
}Code language: JSON / JSON with Comments (json)This manifest registers a compose action button that users can click to trigger a tone check, and it grants access to the compose APIs and message content.
Reading the draft and calling the backend
// background.js
browser.composeAction.onClicked.addListener(async (tab) => {
const details = await browser.compose.getComposeDetails(tab.id);
const body = details.plainTextBody || details.body;
const subject = details.subject;
const to = details.to;
const payload = {
subject,
body,
recipients: to,
targetTone: "professional"
};
try {
const res = await fetch("https://your-backend.example.com/tonecraft/rewrite", {
method: "POST",
headers: {
"Content-Type": "application/json"
},
body: JSON.stringify(payload)
});
if (!res.ok) {
throw new Error("ToneCraft backend error");
}
const data = await res.json();
// Expect data = { analysis: [...], rewrittenBody: "..." }
await browser.runtime.sendMessage({
type: "tonecraftResult",
originalBody: body,
rewrittenBody: data.rewrittenBody,
analysis: data.analysis
});
} catch (e) {
browser.notifications.create({
type: "basic",
title: "ToneCraft error",
message: e.message
});
}
});Code language: JavaScript (javascript)This background script grabs the email content and sends it to your backend, where you will call Regolo’s GPU LLM.
A separate popup.js or panel can listen for the tonecraftResult message and show a diff view where users can accept or reject the rewrite.
Designing the prompt for tone rewriting
Discussions on Reddit about AI email tools show people care a lot about maintaining their own voice while eliminating risky language.
They do not want AI to turn everything into the same bland template, and they especially dislike tools that over‑apologize or change the meaning of what they wrote.
A robust prompt for Regolo should:
- Analyze tone across the entire email, not just a sentence at a time.
- Preserve factual content and intent while softening or clarifying language.
- Respect hierarchy: talking to a manager vs a peer vs a customer.
Example of a backend prompt template:
SYSTEM_PROMPT = """
You are ToneCraft, an AI assistant that makes emails sound professional, clear, and respectful.
Rules:
- Keep the original meaning, facts, and commitments.
- Remove or rewrite unprofessional language (slang, profanity, sarcasm, passive-aggressive phrases).
- Default to slightly more formal than the user's original tone.
- Do NOT invent new information or promises.
- Adapt tone to recipient hierarchy (manager, peer, customer) if provided.
- Output JSON with keys: analysis, rewritten_body.
"""Code language: Python (python)The user payload you send to Regolo might look like this:
user_prompt = {
"role": "user",
"content": json.dumps({
"subject": subject,
"body": body,
"recipients": recipients,
"recipient_role": "manager", # or "peer", "customer"
"target_tone": "professional"
})
}Code language: Python (python)This kind of structure mirrors modern “tone decision frameworks” shared in email‑tone guides, where the tone is selected based on recipient role, urgency, and relationship.
Calling Regolo’s GPU LLM endpoint from your backend
Assume you have a simple Python (FastAPI/Flask) backend that forwards tone checks to Regolo.
Regolo exposes LLMs with a chat‑style HTTP API similar to other providers, but backed by European GPU clusters and strong data‑privacy guarantees.
Backend endpoint
# app.py
import os
import json
from fastapi import FastAPI
from pydantic import BaseModel
import httpx
app = FastAPI()
REGOLO_API_KEY = os.environ["REGOLO_API_KEY"]
REGOLO_BASE_URL = "https://api.regolo.ai/v1/chat/completions"
REGOLO_MODEL = "regolo-llm-pro"
class TonecraftRequest(BaseModel):
subject: str
body: str
recipients: list[str]
targetTone: str = "professional"
@app.post("/tonecraft/rewrite")
async def tonecraft_rewrite(req: TonecraftRequest):
payload = {
"model": REGOLO_MODEL,
"temperature": 0.3,
"response_format": {"type": "json_object"},
"messages": [
{"role": "system", "content": SYSTEM_PROMPT},
{
"role": "user",
"content": json.dumps({
"subject": req.subject,
"body": req.body,
"recipients": req.recipients,
"target_tone": req.targetTone
})
}
]
}
async with httpx.AsyncClient(timeout=10.0) as client:
r = await client.post(
REGOLO_BASE_URL,
headers={
"Authorization": f"Bearer {REGOLO_API_KEY}",
"Content-Type": "application/json"
},
json=payload
)
r.raise_for_status()
data = r.json()
content = data["choices"][0]["message"]["content"]
result = json.loads(content)
return {
"analysis": result.get("analysis", []),
"rewrittenBody": result.get("rewritten_body", req.body)
}
Code language: Python (python)This pattern closely resembles how multi‑provider Thunderbird add‑ons like ThunderAI and AI Mail Support talk to external LLM APIs, while leaving room to swap in different models or providers over time.
With Regolo you can start with a general‑purpose model and later specialize via fine‑tuning or prompt libraries for your company’s tone and terminology.
Privacy, data residency, and trust
Many of the most upvoted comments about AI email assistants are not about features at all—they are about privacy and data usage.
Users want to know whether their emails are stored, used for training, or shared with third parties.
Regolo’s value proposition maps directly onto those concerns:
- Zero data retention: no training on your prompts or outputs, and no long‑term logs of email content.
- European data residency: inference happens on GPU clusters located in Europe, satisfying stricter data‑sovereignty requirements.
- Data‑privacy‑first design: APIs are built to minimize the sensitive data handled, and you can further strip headers or PII in your backend.
You can reinforce trust in ToneCraft by:
- Making the architecture transparent in your docs: explain clearly that email content goes from Thunderbird → your backend → Regolo and nowhere else.
- Providing a “local‑only mode” for high‑security environments, using local models via frameworks like Ollama, while still supporting Regolo for teams that value simplicity and managed GPUs.
UX: blocking, nudging, and respecting the user
There is a fine line between a helpful AI and a patronizing one.
Comments about AI sorting and tagging plug‑ins show that users appreciate strong features, but they want control and visibility—for example, tests to confirm connectivity and options for applying rules to all emails or just new messages.
For ToneCraft, consider:
- Soft default: suggest rewrites but do not block sending unless truly critical (e.g., explicit profanity in a customer email).
- Undo and compare: always let users see the original vs rewritten text and revert easily.
- Fine‑grained controls: per‑account settings (“only check work account”), target tone presets (“polite”, “concise”, “more assertive”).
In the Thunderbird UI, this can be implemented as:
- A compose toolbar button (“Check tone”) with a side panel showing issues and suggestions.
- A toggle in extension settings for “Warn on unprofessional language before sending”, which hooks into
onBeforeSendand prompts the user when needed.
Example: blocking on send when language is clearly unprofessional
You can combine compose.onBeforeSend with a quick Regolo call for a last‑second safety check:
browser.compose.onBeforeSend.addListener(async (tab, details) => {
const composeDetails = await browser.compose.getComposeDetails(tab.id);
const body = composeDetails.plainTextBody || composeDetails.body;
const res = await fetch("https://your-backend.example.com/tonecraft/quick-check", {
method: "POST",
headers: {"Content-Type": "application/json"},
body: JSON.stringify({ body })
});
if (!res.ok) return;
const data = await res.json(); // { hasCriticalIssue: bool, message: string }
if (data.hasCriticalIssue) {
const confirmed = confirm(
"ToneCraft detected potentially unprofessional language:\n\n" +
data.message +
"\n\nDo you still want to send this email?"
);
if (!confirmed) {
throw new Error("User cancelled send due to tone issues.");
}
}
});Code language: JavaScript (javascript)This pattern mimics what many enterprise email‑safety tools do (e.g., DLP or phishing checks), but focused on tone and professionalism.
With a lightweight Regolo model and proper caching, such a check can run in a few hundred milliseconds, so users barely feel the delay.
Getting started with Regolo for ToneCraft
To put all of this together for your own extension or internal tool:
- Set up a Regolo account and endpoint
- Prototype the prompt
- Use your own “worst emails” as test data and iteratively refine the tone prompt.
- Evaluate on internal corpora: support tickets, sales outreach, escalation threads.
- Build the backend wrapper
- Ship the Thunderbird extension
At any point you can switch models, adjust temperature, or add organization‑specific rules without changing the extension itself—the logic lives in the Regolo‑powered backend.
If you want to see this in action with real traffic and not just local tests, you can connect ToneCraft to Regolo’s pay‑as‑you‑go LLM service, run A/B tests on different prompts and models, and track improvements in reply time and escalation rate for your teams.
FAQ
Does ToneCraft write emails from scratch?
ToneCraft is optimized for rewriting and tone‑polishing existing drafts rather than generating full emails from a one‑line prompt, because users on Reddit and X say they trust tools more when they keep control over the core message.
Can I use other models with the same extension?
Yes; the Thunderbird extension talks to your backend, which can route requests to different providers or to local models like Ollama, but Regolo gives you managed European GPU infrastructure, low latency, and privacy guarantees ideal for professional email workflows.
How does ToneCraft handle long threads?
The backend can decide how much of the thread to send to the LLM and can summarize older context before rewriting, addressing a common complaint that AI tools lose context on long conversations.
Will my emails be used to train the model?
With Regolo you can configure strict no‑training and no‑retention policies so that prompts and completions are not used for model training, aligning with user expectations for privacy‑respecting email tools.
Can ToneCraft detect subtle passive‑aggressive phrases?
Yes, by training or prompting the model on examples of phrases that sound polite but are not (“per my last email”, “as I already stated”), ToneCraft can flag them and propose more constructive alternatives, a pattern well documented in tone‑coaching resources.
Is this only for English emails?
No; modern LLMs can handle multiple languages, and Regolo can serve multilingual models so ToneCraft can provide tone adjustments in Italian, English, and other languages common in European companies.
Can enterprises customize ToneCraft for their brand voice?
Enterprises can add brand‑voice prompts or fine‑tuned models behind the same API, similar to how existing AI email assistants learn brand style from uploaded documents.
Resources
- Thunderbird Addon: https://addons.thunderbird.net/thunderbird/addon/tonecraft/
- Repository: https://github.com/Mte90/ToneCraft
🚀 Ready? Start your free trial on today
- Discord – Share your thoughts
- GitHub Repo – Code of blog articles ready to start
- Follow Us on X @regolo_ai
- Open discussion on our Subreddit Community
Built with ❤️ by the Regolo team. Questions? regolo.ai/contact or chat with us on Discord