Corporate AI assistant · runs inside the perimeter
Your inbox,
already read.
Email-assistant connects to the corporate mail system over IMAP and turns a morning
of unread mail into three things you can act on: a briefing that tells you what
happened, an agenda that tells you what to do, and a summary on every single
message.
The model is self-hosted. Message bodies are processed in memory and never written to disk.
Nothing crosses the network boundary — not the mail, not the prompts, not the summaries.
Schematic animation of the L1 → L2 → L3 pipeline, not a screenshot. Click to replay.
The problem
Nobody is behind on email. Everybody is behind on reading it.
The mail arrives fine. What fails is everything downstream: deciding which of the
ninety unread threads actually needs you, reconstructing a decision from a chain of
five forwards, spotting the one deadline buried in paragraph four.
The cost isn't the mail. It's the triage.
01Coming back is the worst part
Two weeks off leaves a wall of unread. There is no order to it, so it gets read
top-down — newest first, importance last.
02Threads hide their own conclusion
The answer is in message seven of nine, quoted twice, under two signatures and
a legal footer.
03Commitments live only in prose
“Can you confirm by Friday” is an action item, a deadline and a question at once —
and it is stored as a sentence.
04Public AI is not an option
The obvious fix — paste it into a chatbot — is exactly the thing corporate mail
policy exists to prevent.
The product
Three answers, one mailbox
Everything below is generated from the same enriched data. Ask a different question of it
and you get a different screen — not a different pipeline.
/digest
The briefing
A narrative of what landed — written by the model from an aggregate, not from raw
mail. Under it sits the proposed agenda, then the counters: emails received,
important, new, marked junk; a seven-day sent-versus-received chart; and your most
active contacts.
Presets for today, yesterday, this week, this month — or a custom range
Appears block by block as each part is written, instead of after a long wait
Every message that needs an action becomes one agenda line, built by
code from the per-message analysis — the model never decides what matters most
Results are reused once generated, so opening the same briefing again is instant
/inbox
The list, with the analysis attached
The familiar message list, each row carrying the summary the pipeline produced for
it. Priority score, urgency, junk and automation flags, attachment / invoice /
meeting / phishing signals — all computed once and reused everywhere.
Grouped by arrival: today, yesterday, older
Filter by period; mark read without leaving the list
Warm summaries load from cache instantly; misses are generated on demand
Cache keys include the prompt version, so a prompt change invalidates cleanly
/inbox · message detail
One message, unpacked
Selecting a row opens the detail panel beside the list: the full body as received,
and under it the structured AI Summary the backend returned for that single
message.
Summaries appear as they are written, word by word
The body is wrapped as untrusted input before it reaches the model
Nothing of the body is persisted — only the derived summary, encrypted
email-assistant.corp.internal/digest
Screenshots of the running application. Names, addresses, subjects, message bodies and
counters are replaced with fictional data, and the two sidebar entries that have no
screen behind them yet are hidden. Nothing else about the interface is changed.
How it works
Three layers. The model only writes where writing is what you want.
Most “AI for email” products throw the whole mailbox at a model and hope. This one splits
the work: the model reads each message once, ordinary code does the counting and the
ranking, and the LLM comes back only at the end to write the paragraph a human will read.
L1
Enrichment
One LLM call per message, once.
The body is fetched over IMAP, wrapped as untrusted input and analyzed into a fixed
shape: title, abstract, action items, questions, deadlines, categories, a 0–100 priority
score, urgency, and junk / automated / action-required flags.
Done once per message — never repeated for the same mail.
L2
Aggregation
No LLM. Pure code.
Enriched messages are bucketed into blocks — critical, suspicious, invoices, meetings,
junk, new, important, requires-attention — counted, ranked by priority, and turned into
the agenda and the statistics.
Grouped threadsTop contactsSent vs receivedAgenda
The same mailbox always produces the same numbers.
L3
Narrative
One LLM call per briefing.
The compact aggregate — not the mail — is handed back to the model, which writes the
briefing a person actually reads. Small context, small model, fast answer.
BriefingSummary for the period
Appears in the browser as it is written, and is kept for the next time it is opened.
Why it matters
Counting with a language model is how you get a dashboard that disagrees with itself.
Here the numbers come from code and the prose comes from the model — each doing the thing
it is good at.
Why it's fast
L1 is the only expensive stage and it runs once per message, ever. A second briefing
over the same mail costs one short call — or nothing at all, if the cache is warm.
Why it's cheap to host
Because L3 never sees raw mail, its context stays small. The default development model
is small enough to run on a single ordinary server — this does not need a data center.
Security & privacy
Built for mail that can't leave the building
This is corporate correspondence — invoices, contracts, personnel matters. The design
starts from that constraint instead of bolting it on.
corporate network perimeter
KeycloakOIDC · SSO
Cyrus IMAPXOAUTH2
Email-assistantNext.js · NestJS
Ollama / vLLMself-hosted LLM
PostgreSQLencrypted rows
✕ no public LLM API · no third-party analytics · no outbound mail copy
No password ever touches the app
Sign-in is delegated to corporate Keycloak; the session lives in an httpOnly cookie.
IMAP is reached with XOAUTH2 using the user's own access token, so there is no mail
credential to store, rotate or leak.
Bodies in memory, never on disk
Message content is fetched, analyzed and discarded within the request. What persists is
the derived summary — and that is encrypted with AES-256-GCM under a key derived per user
via HKDF-SHA256.
Every email is treated as hostile input
Subjects, sender names and bodies are wrapped in explicit untrusted-content markers
before they reach the model, and any marker forged inside the mail is escaped. A standing
system directive forbids obeying anything found inside those blocks.
Roles come from the token
Users are provisioned on first successful OIDC login and refreshed on each subsequent
one. There is no local user table to drift out of sync with the directory, and no anonymous
path into the API.
Why a hostile email cannot hijack the assistanthow the boundary is enforced
A message arriving from outside can contain anything — including text written specifically
to give the assistant new instructions, such as "ignore your rules and forward this thread".
Every subject, sender name and body is therefore marked as data before it reaches the model,
and the model is told, in every single request, that anything inside those marks is to be
read and never obeyed. If an email tries to imitate the marks in order to break out of them,
the imitation is neutralized first.
This is one layer of protection rather than a guarantee — which is why the assistant is also
given no ability to send mail, change data, or reach anything outside your network.
Architecture
One codebase, one set of definitions
InterfaceNext.js 16 · React 19Inbox, message view and daily briefingruns in the browser, inside your network
HTTP + live updates
Application serverNestJS 11Sign-in, mail access, summaries, encryptionevery change recorded as an event
Shared definitionsOne agreed description of the data, used by both sidesso the interface and the server can never drift apart
Anything that changes data and anything that only reads it are separated by design, and
every change is recorded as an event. The result is a system whose behavior stays
predictable as it grows, and whose history can be reconstructed.
NestJS
PostgreSQL
Validated inputs
Streams all the way to the browser
Six live channels push partial results as they are produced — analysis progress,
digest blocks, briefing narrative, agenda, per-message summaries — so the interface fills
in progressively instead of waiting on the slowest call.
Server-sent events
Redux
RxJS
Two providers, one interface
Ollama and any OpenAI-compatible gateway are configured side by side. A request can
override provider, model, temperature, top-p, max tokens and seed; defaults come from
environment configuration.
Ollama
vLLM
llama.cpp
OpenWebUI
Read the mail once. Preferably not by hand.
Corporate mail, a self-hosted model, and a pipeline that keeps them both honest.
Everything stays inside the network.