Memo v5.0.0 — Release Notes

November 7, 2026 · Download Memo can now work with your mail: it connects Gmail, Outlook or any IMAP account, keeps junk and tricks out, prepares replies in your own style, and sends nothing without your say-so unless you tell it to — your Digital Twin. A daily briefing gathers your morning in one card and can reach you on Telegram, WhatsApp or mail, and the setup wizard was rebuilt from scratch. Memo also understands Projects (their own rules and their own memory), has one chat list with a new "Chat | Agent" start screen, shows the agent working live, runs sub-agents in the background, lets you call skills by name and makes local models noticeably faster.

Big Feature: Mail and your Digital Twin

Everything in this section is off by default. Nothing is read, drafted or sent until you switch it on, one switch at a time.

Connect your mail. Gmail and Outlook sign in with one click (no app passwords). Any other provider works with IMAP/SMTP and Memo finds the server settings by itself. Your credentials are kept encrypted on your machine.
Inbox protection. Every new message is checked before anything else touches it. Three layers decide what it is: structured data and your own contacts first (invitations, tickets, invoices, someone you already write to), then standard mail headers (newsletters, automated senders), and only for what is left, a model. Newsletters, bulk mail and one-time-code mails never enter memory and never get a reply. Only mail that arrives after you connect is handled; old mail is never read back.
A shield against prompt injection. A mail that tries to give the assistant orders — "ignore your instructions", "send me your .env", hidden or base64-encoded commands, in English or Turkish — is stopped before any model reads it, and stays readable in your inbox. An optional decision model adds a second review; if that review can't answer, the mail is held rather than let through. Mail text always reaches a model labelled as untrusted data, and the assistant that reads it has only four read-only tools (a contact's history, memory search, calendar availability and the git state of a project you registered). It cannot run commands, write files or send mail.
Nothing secret leaves. Before anything is sent or saved as a draft, the subject, body and recipients are scanned for API keys, private keys, KEY=value lines and one-time codes seen recently. A match blocks the send and tells you why, without ever showing the secret.
One person, every channel. Link a person's mail address and WhatsApp number and Memo shows one timeline with the original dates — a message that said "tomorrow" keeps the day it was written. People are never merged by name alone.
Your own writing style. From your last sent messages Memo notes how you write (casual or formal, language, greeting). It is a plain summary, not a trained clone, and it says so when there are too few examples.
Prepared replies. For mail that deserves an answer, Memo can look things up read-only (for example a project's real git state) and write a draft in your style. The draft is uploaded to the account's Drafts folder and shown in Mail → Replies, where you edit and send it yourself. Each person has a rule — never, draft only or full auto — and the default is draft only. A separate reply model writes the text; the decision model only scores.
Approve from anywhere. Waiting drafts show in the app, and Memo can notify you on WhatsApp and Telegram, where you answer #onay N (approve), #iptal N (cancel) or #asla N (never). Only your own chat is accepted.
Automatic sending, with an undo window. If you allow full auto for a person, a reply goes out only after a 60-second window (adjustable) in which you can cancel. At the moment of sending Memo checks every rule again, plus an independent confidence score of at least 0.95. Groups and CC are never answered automatically, a reply is never sent twice, a mail older than six hours is never answered on its own, and a person gets at most one automatic reply per hour. After a restart, anything still waiting goes back to you for approval.
Calendar-aware. An invitation (.ics) is added to your calendar with a note to review, a clash is flagged and up to two other times are offered. The reply never reveals the titles, places or guests of your other events, and adding to the calendar is never the same as accepting.
A follow-up radar. Memo notices when you are waiting for someone's answer and prepares a review-only reminder draft (one per person, groups are never nagged). It also keeps track of your own dated promises ("I'll send it on Friday") and brings them up when they are due. Both are separate switches.
Ask in chat. The chat can answer "what's waiting for me?", "what did I promise Ali?" and "where did I leave off?" using tools for waiting drafts, open commitments, a contact's timeline and the unfinished work of your projects. A message can become a Self-Driving task — only if you ask, and you write every step. /mail and /twin work in the terminal too.
An audit trail. The twin panel lists what Memo did and why; every outcome comes with a specific reason in your language.

Big Feature: A daily briefing you shape

The morning card. Today's meetings, what was prepared overnight, drafts waiting for you, replies that are overdue, promises due today and unfinished code work — in one card, built from your own data. No model is needed. It is off by default.
A note before a meeting. From 5 to 120 minutes ahead (15 by default) you get the promises you made to that person, the replies you are waiting for, waiting drafts and your recent messages — for people Memo knows by address.
You choose the time and the content. Any half hour of the day, any combination of the six built-in sections, and up to five custom items of your own (a title plus an instruction or reminder).
You choose where it goes. The card is always created in the app; you can also have it sent to Telegram, WhatsApp (your own number, "message yourself") and/or mail (your own address, from the account you pick) — any combination, and only ever to you.
An optional briefing model, separate from the mail reply model. It writes a short summary and answers your custom items from the day's data. Without it no model is called and your custom items appear exactly as you wrote them. If the model fails, the card is still created. The day's data (for example draft subjects) goes to the provider you pick.
Safe delivery. Each send is reserved before it starts, so a restart can never send it twice; a send of unknown outcome is not repeated; a send that failed is retried up to five times, five minutes apart, for up to six hours. The same secret scan as outgoing mail runs on every channel first. Only the morning briefing leaves the app; meeting notes stay in it.
Set it up in the setup wizard (a new step right after Channels) or later in Settings → Mail & Autonomy → Digital Twin.

Big Change: A new setup wizard

The wizard walks a new user through everything that used to need a trip to Settings. Steps marked with * are required; "Next" stays off until a required step is done.

The steps: language and appearance · model connection * (a local model, an API key or a subscription) · embedding model · persona · mail · mail reply model * (only once a mail account exists; it also offers a safe "prepare reply drafts" switch and your time zone) · decision model · memory and learning · voice and images · channels (WhatsApp and Telegram) · daily briefing · privacy and backup · summary and check.
Choosing a local model opens the Model Store in a window, with sizes and a hardware-fit hint, instead of a single recommendation.
It always knows where you are. Progress is read from your real setup (active provider, downloaded models, mail accounts), not from a separate record, so it resumes where you left off and stays right if you change something elsewhere. Every step can be opened directly from the side list.
The summary marks every step as done, skipped or missing, and a row takes you back to that step. It also runs a system check.
You can run it again from Settings → General. A re-run starts from the theme you use and keeps a custom persona prompt you wrote.
The old first-run question about the daily summary is gone; it is a switch in the privacy step now (see Privacy).

Big Feature: Projects

When you pick a folder for an agent chat, Memo asks once: "Set up Memo for this project?" — Set up, Not now or Never for this folder. Nothing is written unless you answer Set up.

What gets created. A small .memo/ folder (generic working rules, a notes file, project settings) and, in the project root, an AGENTS.md and a handoff.md — never over a file you already have, and no second AGENTS.md next to your CLAUDE.md. The rules are about quality and are the same for every language and framework: understand before changing, fix root causes, keep the change small, never say "done" without running the project's real checks, say what you did not verify, don't commit unless asked.
The model reads them when it needs them. A one-line instruction tells it to read .memo/AGENTS.md first. The files are not pasted into every prompt, so prompts stay small.
A memory of its own. A project chat reads and writes only its own project's memory. An ordinary chat still sees everything. A project chat never receives your general memory, your pinned facts, your name, your learned style notes or your custom persona — a client project doesn't need to know who you are. This holds with Code Mode on or off. The memory follows the folder if you move or rename it; a copied folder gets its own.
Your home folder can never be a project. Memo's own install lives in ~/.memo, which has the same name as a project's folder, so Memo refuses your home folder, Memo's own folders and system folders, and never writes into a .memo it didn't create.
Project skills. Add a skill to one project with /skill add owner/repo (or by pasting the npx skills add … line from its README, or asking the agent). Memo reads the source out of the line and downloads plain files — it never runs npx or anything else. A project skill is instructions only (the tools it declares are ignored) and stays out of the prompt until you switch it on with /skill:on.
Permissions for a project. A project can pre-approve command prefixes and file tools in .memo/permissions.json so Memo stops asking about them; anything that doesn't match asks exactly as before. Memo only honours that file after you approve it on this device (today through Memo's local API; there is no screen for it yet). A file that arrives with a cloned repository, or that the model wrote itself, is ignored until you approve it, and ignored again if it changes later. A file with even one bad rule is ignored as a whole, and the project's own AGENTS.md can never grant anything.
Setup never overwrites. Creating the project files no longer makes a second AGENTS.md or handoff.md that differs only in letter case (it did on Linux), and never replaces a file another program created in the meantime.
Minimal Mode stays a pure wrapper: no setup question, no instruction, nothing read. Self-Driving tasks with "task memory" off neither read nor write project memory.

Big Change: One chat list, and a new start screen

The separate Agent tab is gone. There is one chat list; an agent chat is a chat with a project folder and is marked with a robot icon. The Code Mode switch and the Tasks button live in the chat's top bar for agent chats.
A new chat starts on a new screen: a Chat | Agent switch, a centred composer with the model picker, and starter suggestions. You choose Chat or Agent before the first message and it stays that way. The composer drops to the bottom after you send.
A blank chat is listed first, and New Chat reopens it instead of piling up empty chats. Agent chats get a title from your first words.

Agent: you see the work as it happens

Live. The agent loop now streams: the model's text next to its tool calls ("I'll check the config first"), its thinking and each tool call appear in order as they happen, instead of a spinner and then a wall at the end. Tool calls are grouped ("Ran 3 commands") and open to show what ran.
Long turns no longer lose the task. A long coding turn used to crash with a context-size error after dozens of steps, and before that forgot your request while keeping the newest tool output. Memo now keeps your request and the earlier conversation, replaces old tool output with a one-line stub when the budget is reached, and measures a long conversation against a sensible ceiling instead of a 1M-token window.
No more giving up on an empty step. If the model returns nothing after using tools, Memo nudges it to answer from what it found before showing "couldn't generate a reply". Models that stay silent between tool calls are asked to say what they are doing.

Big Feature: Sub-agents

In an ordinary agent chat Memo can hand a bounded job to a sub-agent — when it decides delegating helps, or when you ask. Sub-agents work in the background: you keep talking to the main agent, and it keeps working, replying or waiting without polling.

Each sub-agent is focused. It gets its task, the coding instructions and only the skills selected for it — never your personal memory, your persona or the rest of the conversation. A read-only sub-agent can look at files and search the web; a coding sub-agent can also edit files and run commands, and your permission rules still apply.
Parallel writers don't collide. Sub-agents that change files each work in their own separate copy of the project; their results are checked and merged one at a time, and a conflict is kept for you instead of being thrown away.
You can watch and steer. Sub-agents appear as cards in the chat. Open one to see the task it was given, its live output, its tool calls, and to send it a follow-up. Finished sub-agents move into a history list and stay inspectable after they are closed.
Results always reach the conversation. Your messages, attachments and sub-agent results are delivered through one queue per chat; a result is only counted as delivered once the main agent has replied to it. If a review was interrupted, the main agent picks it up again.
Same model as the turn that started them. A sub-agent keeps the provider, model and effort of that turn. If the provider was removed or a local model stopped, it fails with a clear message instead of quietly switching to another model.
Settings → Chat sub-agents sets how many run at once (1–16, default 3), separately from Self-Driving.
Healthy sub-agents are no longer killed by the 20-minute limit meant for interactive turns, and the main agent now sees which sub-agents really are running, failed or finished.

Skills: call them in your message

Name a skill in what you write and it is switched on for that chat: fix this with /pair-programming, fix this using the Pair Programming skill, or fix this using the necessary skills (Memo picks the best matches). The skill's instructions are already in the turn that called it, a new chat starts with none, and the answer shows which skills were used — a reload still shows them.
Typing / anywhere in a message lists your installed skills plus the commands that do something real: /remember, /forget, /model and /orchestra. Picking one replaces just the word you typed. The canned prompt templates and the per-chat skill switch dialog are gone.

Terminal: use it next to the desktop app

The terminal chat's settings (auto-permission, web tools) now belong to that terminal session only, and opening a chat there no longer moves the desktop app's open chat. Two clients can share one Memo.
It shows thinking, the model's words and every tool call live, and leaves one line per finished call (what ran, how long, or the error).
Typing / lists Memo's commands and the installed skills with their on/off state; /skill lists and toggles them for that chat.

Local models: faster answers

Memo now picks the engine by what your machine can really use. It used to take the first bundled engine folder; on a computer whose graphics chip the GPU engine can't drive (an integrated AMD or Intel GPU, for instance) that quietly meant running everything on the processor. Memo now asks each engine which GPUs it sees and chooses accordingly. With a Vulkan driver, prompt processing was about 2.2× faster in our test (a 1,641-token prompt: 66 → 146 tokens per second with the Phi-3 mini model on a Ryzen 5 5600H with built-in graphics), so the first word of a reply to a long prompt arrives in about 11 seconds instead of 25. The speed of the reply itself doesn't change, because that is limited by memory speed and built-in graphics share the same memory as the processor. We measured one model on one machine: the gain depends on your processor, your graphics chip and the model, and a very short message can be a fraction of a second slower. Linux for now.
Code-heavy replies are up to 3× faster. The local model now guesses upcoming words from text it has already seen and checks them in one step. Copying or rewriting code went from about 15 to about 50 tokens per second in our test (Phi-3 mini); ordinary prose is unchanged, and the answers were identical in our tests. It is not used for models that read pictures, for memory embeddings or for Swarm. Set MEMO_LLAMA_SPECULATIVE=off to turn it off.
Memory and speech stay on the processor. The memory (embedding) model and speech-to-text deliberately don't use the GPU: on it the memory vectors differ slightly from the ones already stored, and speech accuracy wasn't verified. Engine mode CPU now really turns the GPU off.
Engines updated: llama.cpp b11669, whisper.cpp 1.9.5 and CLIProxyAPI v8.0.43 (Linux). The install scripts now refresh engine folders that are older than the published ones, and the engine-update window shows a finished update as done instead of leaving "Update now" active.

Privacy: an anonymous daily summary (on by default in official builds)

Please read this one. In official builds Memo now sends a short, anonymous daily usage summary by default. This also applies if you are updating from a version that had no such feature, and no question is asked. You can turn it off at any time.

How to turn it off. The privacy step of the setup wizard, or Settings → Privacy (one sharing switch). If you had already said no, that choice is kept. Builds made from source send nothing unless you turn it on; MEMO_TELEMETRY=off also switches it off.
What it contains. A random install ID (not tied to you or your hardware), the Memo version, system and language, the class of your graphics card and rounded memory sizes, how much each kind of model and provider was used (types and catalogue names, counts, token totals, speed ranges), the classes of errors that happened, update results, where Memo itself crashed (function names and file/line from Memo's own code), which features were used, and a size range for your memory.
What it never contains. Messages, replies, chat titles, memory contents, contacts, calendar, WhatsApp or Telegram content, pictures or audio, file or project names and paths, keys, passwords, e-mail addresses, your user or computer name. Private chats and Minimal Mode turns are not recorded.
When it is sent. Only completed days after sharing started are reported, about every three hours; if you were offline, up to eight days back are tried.
One more thing, even if daily sharing is off. Once per data folder an official build sends an install count with only the version, system and architecture — no ID.
You can see it first. In the terminal, memo telemetry status shows the state, preview shows the exact report before anything is sent, on and off switch it, reset-id makes a new random ID and delete asks for the data of your ID to be deleted.
The report itself carries no IP address, but like any web request the server's connection sees where it came from.
Details: docs/TELEMETRY.md.

Security

Mail is treated as hostile text (see Mail and your Digital Twin): a deterministic injection shield, an optional second review that fails closed, an outgoing secret scan and a research assistant limited to four read-only tools.
The agent's read-only shell is stricter. Commands that chain other commands, redirect output or pass flags that execute something are no longer allowed in read-only mode.
Dependencies updated. A compression library (GO-2026-6865), the network library and the Go toolchain were upgraded after vulnerability reports; the project's security scan passes.
A failed Subscriptions start no longer leaves its connector running.

Improvements

A folder and file picker you can use: paste or type a path (~ works), filter as you type, hidden folders are off by default (with a toggle), recent folders as chips.
The agent chat's top bar has the model and reasoning-effort pickers the plain chat has.
Fixed: picking a file from the @ list with Tab dropped the keyboard; the list now keeps your selection in view and mentions show in blue.
Fixed: the new-chat composer's bottom row is flush (send at the edge, model button beside it).
Stopping an answer keeps what you saw. Stopping an agent used to replace everything with one "stopped" line; the tool calls, the text it was writing and its thinking now stay.
Jump to latest. A down-arrow button appears when you have scrolled away from the newest message and takes you back in one click.
The desktop app recovers a lost server connection without closing; the "can't reach server" card and the address dialog scroll in a narrow window.
The memory (embedding) model starts by itself on new installs, comes back after a crash, and remembers when you stopped it on purpose.
Self-Driving: a long single-action task item runs on one worker instead of four, and workers keep the project's rules and the retry history.
Fixed: Turkish picture requests such as "resmi üretsene" now reach the image model; before, the text model claimed a picture it never made and that made-up reply was remembered.
Fixed: a background refresh could overwrite the model you had just chosen for Memo Subscriptions.
Fixed (Linux): the local model, voice input or Swarm could refuse to start with "permission denied" because engine files had lost their executable permission when they were downloaded or copied. Memo now repairs that itself just before it starts them.
The context meter shows the real window. It used to show 16.4K for every cloud model, because a stale setting in config.yaml beat everything and, underneath, the size was guessed from the provider type or the model's name. Memo now asks the selected provider itself (Anthropic, Gemini, OpenAI-compatible /models, Ollama, the local llama server), falls back to a public model catalogue, and otherwise says it doesn't know. It never guesses from a name, never waits on the network, and warns at startup if the old global override is still set.
Relative dates in memory stay true. "Tomorrow" is now anchored to the day the message was written, so an old note doesn't read as if it were about today.
The chat can use your calendar, mail and WhatsApp tools without Agent mode.
Mail looks and counts right: Turkish characters in mail headers and bodies decode correctly, a mail's layout is kept, unsafe embedded styling is skipped instead of breaking the page, addresses with names send correctly, and a slow mail server no longer shows up as "Internet connection issue" on the web version.
Accepted mail is never lost, even if something fails right after it arrived, and a cancelled reply records why.
Fewer ordinary mails held by the safety review: it now gets 15 seconds instead of 5 and is retried once. A Turkish "please do not share this code" warning and a plain "ignore my previous email" are no longer taken for attacks.
A new mascot: the sidebar shows a random still mascot as its logo, and the desktop mascot window is reused when you toggle it instead of piling up. Settings → Privacy has one sharing switch instead of several.

Known limitations

Mail and the Digital Twin were tested with two real Gmail accounts and a real model, and with automated tests; they have not yet been tried on real devices. Not yet verified: approving from WhatsApp or Telegram, voice messages, .ics invitations arriving as real attachments.
The daily briefing has widget and unit tests, but a real delivery to Telegram, WhatsApp or mail (WhatsApp "message yourself" in particular) and a briefing written by a real provider have not been run yet. The setup wizard and the briefing panel have not been checked by eye either.
A slow model as the safety reviewer can hold an ordinary mail ("review unavailable") or make an automatic reply fall back to a draft. Pick a fast model as the decision model.
A plain-text "can we meet tomorrow at 3?" is not added to the calendar; only real .ics invitations are.
Mail accounts are not part of backups or cloud sync. After restoring on another machine, connect your mail again.
Until you pick a time zone it stays UTC, so a briefing time is read in UTC; the wizard asks, and you can change it under Working hours.
Project permissions (.memo/permissions.json) still have no screen: they are approved through Memo's local API.
The local-model speed-ups and the engine-folder choice are Linux only for now.

Good to know

Everyone gets the setup question once per project folder. Say Never for this folder to stop it for that folder.
One-time database change. Memory gets one new column; none of your existing memories are rewritten, and each keeps its content, embedding and search index entry. Before touching a database that has memories, Memo saves a full copy to data/backups/memory-pre-project-id-….db. The copy includes your latest memories even if Memo was closed abruptly, it stays on your machine, is not part of exports or cloud sync, and is never deleted automatically (you can remove it once you are happy). If the copy can't be written, the change is skipped: normal chats work exactly as before and project chats have no memory until the next start. An older Memo can still open, search, add to and export the upgraded memory file; it doesn't know about projects, so project memories look like ordinary ones to it.
Mail and the Digital Twin are off by default, and so are autonomous replies, the follow-up radar, the briefing and project inspection. You turn each on yourself.
The anonymous daily summary is on by default in official builds, also when you update from an older version (see Privacy). It takes one switch to turn off.

Thank you for using Memo — github.com/BugraAkdemir/memo