A guide, read like a book

The Memo Guide

This isn't a documentation page — it's a guide meant to be read start to finish, the way someone who actually lives inside Memo would explain it to you. What each feature does, how they combine, and what to do when something goes wrong.

52 min read·18 chapters
Would rather not read it yourself?

Copy this, paste it into your own AI assistant — it'll read this page for you and answer whatever you want to know about Memo.

The Memo Guide

01What Memo Actually Is

There's a specific kind of unease that comes from typing something private into a text box owned by someone else. Maybe it's a half-formed business idea, a symptom you're worried about, a draft email to someone you're not on good terms with, or just the shape of your day — when you wake up, what you worry about, who you talk to. Every popular AI chat assistant asks you to hand that over to a server you'll never see, run by a company whose incentives are not quite the same as yours. Memo starts from a different premise: what if the assistant just lived on your machine instead?

Memo is a chat application built around a local language model, running entirely on your own computer, with your conversations, your memories, and your data never leaving your disk unless you explicitly tell it to. It's built with a Go backend that does the actual thinking — talking to a local llama.cpp process, or, if you choose, to an external provider like OpenAI or Claude — and a Flutter frontend that gives you somewhere pleasant to have the conversation, on desktop or on your phone. Underneath the chat window sits a memory system that behaves less like a search engine and more like an attentive friend: it notices what you tell it, holds onto the parts that matter, and quietly brings them back up later when they're relevant, the way a person who's known you a while does. On top of that sits a second layer entirely, an agent that can actually touch your filesystem and run commands when you let it, a mode where several models argue a problem out amongst themselves before answering, a bridge into your WhatsApp, a calendar and a set of routines that let Memo act without waiting to be asked, and a handful of quieter tools — cloud backup, remote access from your phone, a gateway that lets Claude Code itself run through your own local model — that only reveal themselves once you go looking.

None of this is a product built by a company with a roadmap and a board. Memo is written, largely alone, by a developer who cared enough about the privacy question to spend the time building an alternative rather than just complaining about the state of things — and who happens to be sixteen. There's no telemetry hiding in a corner phoning home with your usage patterns, because there's no business model that would want it there. The whole thing is open source, released under AGPL, which means you're free to read every line of what's actually happening to your data, and free to walk away with it if you ever wanted to. That's not a marketing angle so much as the actual reason the project exists: a second brain that's actually yours, running on hardware you control, saying things back to you that only you and your own machine ever heard.

The rest of this guide walks through what that looks like in practice — how to get it running, what happens under the hood when you have an ordinary conversation, and everything that opens up once you start pulling on the more advanced threads: agents, orchestras, routines, swarms, and all the rest.

02Getting It Running

The first few minutes with any new piece of software set the tone for everything after, and Memo tries hard to make those minutes forgiving rather than intimidating. You download a binary for your platform — Linux, Windows, or macOS — and the first thing it does, before it ever shows you a chat window, is quietly look at your own machine: how much RAM you have, whether there's a GPU worth talking to, and what kind of local model would actually run well on that hardware rather than choking it. This hardware-aware recommendation step, part of the model store overhaul in the current release line, reads your system and suggests a matching pair of models — one for chatting, one smaller one dedicated to embeddings for memory — in plain language, with a single button that starts both downloading in the background while the rest of first-run setup continues around them. You're not left guessing whether a 70-billion-parameter model will even boot on your laptop; Memo already ruled that out for you before you had the chance to pick it and be disappointed.

That first-run flow is also where you make the one decision that actually shapes how the rest of the app feels: do you want to run a model locally, or connect Memo to an external provider's API? These aren't mutually exclusive, and you can change your mind constantly, but they represent genuinely different trade-offs. A local model means everything happens on your machine — no API key, no per-token cost, no data ever crossing your network boundary, but you're bound by whatever your GPU and RAM can actually push through, and a local model won't match a frontier model's reasoning on a hard problem. An external provider — OpenAI, Anthropic's Claude, Google's Gemini, xAI's Grok, and several others — gives you access to state-of-the-art capability instantly, at the cost of an API key, a per-token bill, and the fact that your messages now do leave your machine, headed to that provider's servers, for as long as that conversation is active. Memo doesn't push you toward one or the other; it just makes both first-class citizens of the same chat window, switchable at will, and treats "no model configured at all" as the one state it actively tries to get you out of during setup.

Once a model is running — local or external — you're in the same app you'll be in for months: install is genuinely a single binary, first run is a guided setup that ends with a working chat, and everything from that point forward is really just discovering what's already there.

If something does go sideways during this phase, it's almost always one of two things. Either the recommended local model turns out to be a poor fit after all — usually because the hardware detection under-read your available VRAM, in which case the Model Store's Discover tab lets you pick something smaller by hand — or the external provider connection fails silently because the API key was mistyped or the wrong base URL got left in from a previous provider you were testing; the "Test Connection" button in the provider dialog exists specifically to catch this before you're three messages into a conversation wondering why nothing's coming back.

03An Ordinary Conversation, and the Memory Working Underneath It

On the surface, talking to Memo looks exactly like talking to any other chat assistant: you type, it replies, tokens stream in. What's different is invisible, and it's worth understanding because it explains a lot of what feels almost eerie about using Memo for a few weeks — the way it brings up your dog's name unprompted, or remembers a decision you made in a conversation from a month ago that you'd half-forgotten yourself.

Every message you send gets converted into a numerical vector by a small embedding model running locally, and that vector is compared against every past conversation you've ever had with Memo, stored in a SQLite database sitting quietly in your data directory. This is retrieval-augmented generation — RAG — and it's the reason Memo's replies feel informed by history rather than starting fresh every time. But pure vector similarity search, on its own, has a specific weakness: when you ask something that spans several topics at once — "do you know my name, my birthday, and my favorite color" — the whole question gets flattened into one averaged vector, and a short, simple fact like a favorite color can end up not similar enough to that blended average to surface at all, especially once your memory store has accumulated months of unrelated conversation. Memo works around this in two ways. First, it splits a compound question on its conjunctions before searching, so "name, birthday, and favorite color" becomes three separate searches instead of one blurred one. Second, vector search runs alongside a genuine keyword search — the kind that catches an exact word match regardless of how the embedding model happened to place it in vector space — and the two result sets are merged together, so a precise fact isn't purely at the mercy of semantic drift.

On top of both of those sits a third layer that doesn't depend on search ranking at all. Certain facts — your name, your birthday, people and pets you've mentioned, anything explicitly durable and personal — get pinned, and pinned facts are injected into every single prompt unconditionally, bypassing the whole retrieval-and-ranking pipeline entirely. This is why Memo can reliably tell you your own name back even in a session where the rest of memory search comes up dry: that one category of fact isn't competing for a slot in the results, it's just always there. You can pin something explicitly with the /remember command, but as of the current release Memo also runs a quiet background check after each turn to notice when you've stated a durable personal fact in the middle of ordinary conversation — "my dog's name is Zeytin," said in passing — and pins it the same way, without you ever having to invoke a command. That's the answer to the slightly uncanny experience of Memo remembering something you never explicitly asked it to remember: it decided, on its own, that what you said sounded like the kind of fact worth keeping permanently, the same judgment call a person makes when they file away something you mentioned once and bring it back up weeks later.

If it feels like Memo has forgotten something instead — told you flatly "no" to a question about a fact you're fairly sure you mentioned — there are a few usual suspects worth checking before assuming something's broken. The most common is a compound question competing against itself: if you're asking about several things in one sentence and only some of them come back, that's the crowding effect above at work, and simply asking about the missing piece on its own, as a separate message, will usually surface it fine. The second is that the fact you're thinking of was mentioned once, in ordinary conversation, days or weeks ago, and simply never got flagged as pin-worthy by the background check — casual mentions aren't a guarantee, only a best effort, and explicitly saying "remember that..." is still the reliable path for anything you genuinely can't afford to lose. And the third, quieter possibility is that the embedding model simply isn't running — memory search depends on it, and if it failed to start (a stale process from an earlier crash still holding its port, for instance) Memo can end up silently degraded to a much weaker fallback with no obvious error surfaced to you. The Settings status area shows whether the embedding model is actually alive; if a fact you're sure you gave it seems to have vanished across the board rather than in one compound question, that's the first place to look.

04Agent Mode: When Chat Isn't Enough

There's a real difference between an assistant that can talk about your code and one that can actually open the file, read it, and fix the bug itself — and that difference is Agent Mode. Turn it on, and Memo stops being purely a conversational partner and becomes something closer to a careful, permission-gated coworker sitting at your keyboard: it can read and write files, list directories, run shell commands, search across a codebase, and check environment variables, feeding each result back into its own reasoning before deciding on a next step, in a loop that can run up to twenty iterations before it has to stop and give you a final answer.

This isn't available everywhere, on purpose. Tool use — the technical capability that lets a model decide "I should call this function with these arguments" rather than just producing text — is something local llama.cpp models don't reliably support yet, so Agent Mode requires an active external provider. As of the current release, the toggle for it sits right in the Chat screen's own top bar, next to the web-search toggle, which resolves what used to be real friction: earlier, turning tools on meant leaving the ordinary Chat screen entirely for a separate Agent tab, and a lot of people simply never discovered that tab existed. If you've been wondering where the switch is, that's almost certainly the answer — it's not buried in Settings, it's right there above the message box, but only once you're on an external provider.

Every tool call the agent wants to make passes through a permission system before it actually runs. Some tools — reading a file, listing a directory — are considered safe enough to execute without asking. Others, like writing a file or running a shell command, prompt you first, and you get real choices: allow it once, allow it for the rest of this session, allow it permanently, or deny it in any of the same gradations. Those permanent decisions get written to disk so Memo doesn't ask you the same question every single day forever, which is where the auto-permission mode comes in — a Shift+Tab toggle for people who trust the agent enough on their own machine that they'd rather not be interrupted for every routine tool call. A subtle timing bug used to mean this toggle could visually flip on in the UI while the agent kept prompting for permission anyway underneath, which is exactly the kind of thing that erodes trust in a permission system fast; it's been fixed, but if you ever find yourself still being prompted after supposedly turning auto-permission on, updating to the current version is the fix, not fighting with the toggle further.

Underneath all of this sits a sandbox that exists specifically because a language model occasionally decides on something you'd never actually want executed. Every path the agent touches is validated against the project's base directory, with symlinks resolved before the check happens rather than after — an earlier gap here meant a symlink inside a sandboxed project that pointed at a file which didn't exist yet could let a file-editing tool escape the sandbox and write somewhere it shouldn't, which was found and closed. A blacklist of roughly two dozen dangerous shell patterns — recursive deletes of root or home directories, disk formatting commands, fork bombs, privilege escalation, reverse shells — is checked before any command actually runs, as a second net underneath the permission prompt you already had to approve. That blacklist itself has had its own bugs: an early version anchored its pattern matching on word boundaries, which don't actually exist around characters like /, ~, or ., so the exact commands the filter existed to catch — rm -rf / chief among them — could slip straight through unblocked while a completely harmless command elsewhere got flagged instead. That's been fixed, and it's a good example of the general shape of what to expect from a permission-and-sandbox system this young: it's taken seriously, bugs in it get treated as security bugs and fixed quickly once found, but "the agent has a safety net" and "the safety net has never had a hole in it" are different claims, and the honest one to make is the first.

Agent Mode is genuinely good for anything that benefits from a tight read-execute-verify loop — refactoring a function and then actually running the test suite to check it, searching a large codebase for every place a pattern appears, editing a config file and confirming the change took. It's the wrong tool for a conversation that's really just about thinking something through out loud, where there's nothing to read or execute and the tool-calling loop just adds latency for no benefit — that's what plain chat, or Orchestra Mode's multiple perspectives, are for instead. If agent runs feel like they fail unpredictably against a specific provider with a cryptic 400 invalid_request_error, that was a real bug where an internal bookkeeping field leaked into the tool definitions sent to that provider's API and got rejected by stricter validation on their end — fixed in the current release, and chat now also surfaces the provider's actual human-readable error instead of dumping raw JSON at you when something does go wrong.

05Orchestra Mode: When One Model Isn't Enough

Some questions don't have a single right answer so much as several partial ones that need reconciling — "build me a small web app" touches frontend design, backend logic, and security review all at once, and no single model prompt handles all three angles equally well. Orchestra Mode is Memo's answer to that: instead of one model doing everything, a Chief model reads your request, breaks it into discrete subtasks, and assigns each one to a specialized Expert Role — a frontend specialist, a backend specialist, a bug-fixer, a security reviewer, a DevOps role, and a few more — each of which can be pointed at a different underlying model. The frontend role might run on one provider known for clean UI code, the backend role on another that's stronger at systems logic, the security role on whichever model you trust most for that kind of scrutiny — and once all the experts report back, the Chief synthesizes their separate answers into one coherent response rather than handing you three disconnected fragments.

The honest trade-off here is latency and cost, and it's a real one. A single Orchestra request means a planning call, then however many expert calls the plan calls for (run in parallel when they're independent, or sequentially when one depends on another's output), then a final synthesis call — which in practice means several times the tokens and several times the wait of just asking one model directly. It's worth it when a task genuinely spans domains that benefit from different strengths, and it's overkill for anything that a single competent model handles fine on its own — asking Orchestra to summarize a paragraph is spending five separate model calls' worth of latency on a job that needed one.

You reach Orchestra's settings under its own tab, where you assign the Chief and configure which roles are active and which model backs each one; a handful of roles come enabled by default with sensible model assignments, and the rest sit there disabled until you decide you want them. Once Orchestra is switched on for a chat, it takes over that chat's input entirely — the ordinary send button is disabled, and only slash commands or messages headed through the conductor go through, which is worth knowing about ahead of time so it doesn't feel like the chat box just broke. /orchestra status gives you a quick readout of the current configuration without opening the full dialog, and /orchestra off gets you back to a normal single-model conversation the moment you don't need the extra machinery. One thing to know going in: Orchestra creates its own connections to each role's provider directly, bypassing the same automatic fallback chain that ordinary chat relies on — so if a role's assigned provider has an outage or hits a rate limit mid-plan, that specific task fails rather than quietly falling back to a different provider, which is a deliberate simplification rather than an oversight, but worth knowing before you're troubleshooting a failed task that a plain chat message to the same provider would have handled fine.

06External Providers and Switching Models

Underneath both Agent Mode and Orchestra Mode — and available on its own, for plain chat too — sits Memo's provider system, the layer that lets it talk to OpenAI, Anthropic's Claude, Google's Gemini, xAI's Grok, Groq, OpenRouter, a local Ollama instance, and, added in the current release, OpenCode's two gateways, OpenCode Zen and OpenCode Go. Each one gets configured the same way, under Settings → API Providers: pick the provider type, give it a display name if you're running more than one of the same kind, paste in an API key, optionally point it at a custom base URL if you're using something OpenAI-compatible like a self-hosted proxy or LM Studio, and choose which model that provider should use. OpenRouter, OpenCode Zen, and OpenCode Go are a little friendlier here than typing a model name from memory — since they front hundreds of models between them, the provider dialog lets you pick from the actual live list the API reports rather than guessing at an exact model string.

Behind the scenes, once more than one provider is enabled, Memo treats them as a fallback chain rather than a single hard choice: if a request to your primary provider fails — a timeout, a rate limit, an authentication error — it's retried against the next enabled provider in line, and a provider that fails three times in a row gets automatically disabled rather than kept failing every subsequent message, with a background health check quietly retrying it every few minutes and re-enabling it automatically once it recovers. This is the layer of resilience that ordinary chat and Agent Mode both benefit from — Orchestra, as mentioned, deliberately opts out of it in favor of pinning each role to its exact configured model.

API keys themselves are encrypted at rest with AES-256-GCM, using a key derived from your machine's own identity and, as of a recent fix, backed by a randomly generated key file rather than a hardcoded fallback — which closed a real weakness where an unset machine ID used to fall back to a constant baked into the binary itself, the same for every install. The most common setup mistake is one of three things: pasting a key with a stray leading or trailing space (surprisingly common when copying from a terminal or a password manager), leaving a base URL pointed at a previous provider you were testing when you meant to reset it to the default, or enabling a provider without ever hitting "Test Connection" first and only discovering the mistake three messages into a conversation that's producing nothing. That test button exists exactly to catch all three before they cost you a confusing debugging session later. One structural quirk worth knowing: because these encrypted keys are tied to your specific machine's identity, a raw copy of providers.json from one computer generally can't just be dropped onto another and decrypted — this is exactly why the full backup and restore system, covered later in this guide, bundles the machine key alongside the encrypted config rather than leaving you to move the config file alone.

07Local Models, llama.cpp, and Discovering New Ones

Running a model on your own hardware is where Memo's local-first promise becomes something you can actually feel — no network round-trip, no per-token bill, the whole thing living inside the process tree of your own machine. That local inference is handled by llama.cpp, an efficient C++ inference engine that Memo manages as a background subprocess: it downloads the right binary for your platform automatically, starts it up when you load a model, and shuts it down cleanly when you're done, all without you ever needing to know llama.cpp exists as a separate piece of software underneath.

Finding a model to run happens in the Model Store's Discover tab, which searches Hugging Face directly for models in the GGUF format llama.cpp actually uses, filtering out formats that wouldn't work before they ever show up as an option. You can also paste a Hugging Face repository URL directly to jump straight to a download rather than searching. Before you commit to a download, Memo checks your GPU's VRAM capacity and shows a compatibility badge telling you honestly whether a given model will run efficiently on your hardware or whether you're looking at something that'll be painfully slow or simply won't fit — and if a model needs GPU offloading, the setting that controls how many of its layers get pushed onto your graphics card versus handled by the CPU is right there in Advanced Settings, with "as many as will fit" being the right instinct for maximum speed on capable hardware.

A few of the rougher edges here have been smoothed out recently and are worth knowing about if you've used an older version of Memo and found the Discover tab frustrating. Downloads used to block each other outright — starting a second one while the first was running got flatly rejected — and now several can run concurrently, with combined progress shown in the engine status bar. The context-size field used to be free text with no ceiling, which meant typing an unrealistic number could crash the model server outright; it now reads the model's actual maximum context straight from the file and won't let you exceed it. The badges indicating whether a model supports tool-calling or code generation used to come from a hardcoded list of "known" model families, which meant anything new or less mainstream got silently mis-labeled; they're now derived from the model's actual chat template and tags, which is slower to be impressively confident about brand-new releases but considerably more honest about everything else. And filters for things like Tools, Vision, Code, or a specific size range used to combine with an implicit AND, so selecting two filters at once often returned nothing at all even when matching models genuinely existed — they now combine with OR, and they're grouped into proper multi-select dropdowns with a small "N filters active" indicator instead of a flat, easy-to-lose row of chips.

One thing that trips people up specifically: some of the more capable or more popular models on Hugging Face are gated, meaning the repository owner requires you to accept a license agreement on the Hugging Face website itself before you're allowed to download the weights, even anonymously. Memo can't get around that gate for you — you'll need a Hugging Face account and a personal access token, entered once in Settings, before a gated download will succeed rather than failing with an authentication error partway through. A related issue that's been fixed: gated downloads that failed with a 401 used to leave the download button permanently stuck reading "Cancel" instead of resetting, which looked like the app had frozen when really the download had simply failed and needed to be retried after the token was actually added.

08The Terminal CLI

If your instinct is to live in a terminal rather than a windowed app, Memo has a whole second interface built for exactly that: a REPL-style command-line client that talks to the same REST API the Flutter frontend does, just from a terminal prompt instead of a window. It's aimed squarely at people who'd rather type /model and @some_file.go than click through menus, and the current release line gave it a genuine visual redesign — a welcome panel done in a warm bronze palette, laid out as a single box split into two columns, mascot and model/path information on one side, a rotating tip and update notice on the other, formatted to hold together properly no matter how you resize the terminal window instead of distorting the way earlier layouts did.

Inside the REPL, slash commands are how you steer things without breaking out of the chat flow: /model switches which model is active, /session lets you jump into any earlier conversation — and as of the current release, that includes chats started from the desktop app too, not just ones begun in the CLI, so you can genuinely move between the two interfaces mid-conversation in either direction. /gui launches the desktop app directly from the terminal, /update checks your version against the server, and typing @ in the middle of composing a message opens a file-mention autocomplete that lets you reference a specific file in your project without typing its full path by hand. Beyond the interactive REPL, a handful of standalone flags let you script against Memo without ever opening a chat session at all: --status, --version, --kill to shut down a running backend cleanly, --gui, --github, --bugreport, and --docs each do one specific thing and exit.

The CLI's relationship with the desktop app used to be a real source of frustration: if the terminal had started its own backend process and you then opened the desktop app alongside it, closing the terminal would silently take the backend down too — and the desktop app along with it, mid-conversation, with no warning. That's been restructured so the backend now runs as its own independent process, kept alive as long as either the CLI or the desktop app is actually using it, and only shutting itself down on its own, after roughly a minute or two of true idle time, once neither one needs it anymore. A related change: the CLI used to automatically resume your last conversation on open, which meant old context showed up whether you wanted it there or not; it now always starts a fresh chat, with /session as the deliberate way back into history whenever you actually want it, rather than by default every single time.

If you find the CLI still behaving oddly after an update — a stale welcome banner, a stuck terminal state after closing it some way other than /exit — the most common cause by far is simply running an older cached binary; the standalone builds and the beta installer scripts (get-memo-beta.sh/get-memo-beta.ps1, kept deliberately separate from the stable line for people who want to track beta releases specifically) are the paths worth checking before assuming a fix hasn't landed.

09WhatsApp Integration

There's something a little unusual about an AI assistant that can see your actual WhatsApp conversations, and Memo is careful about how it frames that: it connects to your account through WhatsApp's own multi-device web protocol, the same one WhatsApp Web itself uses, which means there's no separate business API fee and no need to register a new phone number — you scan a QR code from inside Memo, the same way you'd link WhatsApp Web on a browser, and you're connected.

Once linked, Memo gives you a dedicated WhatsApp interface inside the app: you can read and search across your chats, and ask the AI to draft a reply or summarize a long thread rather than scrolling through it yourself. Because Agent Mode's tools extend into WhatsApp too, an agent run can search your messages, pull up the latest ones in a conversation, or actually send a reply on your behalf if you've granted it permission to — the same permission-gated model that governs file and command tools governs this too, so "the agent can message people for you" isn't something that happens without you explicitly allowing it. Contact name resolution means you can just say "message Berra" and have Memo figure out who that refers to from your contacts, rather than needing an exact phone number. Everything — messages, contacts, cached profile photos — is stored locally in its own SQLite database inside your data directory, alongside your WhatsApp session credentials, and it feeds into the same proactive systems the rest of the app uses: a plan mentioned in a WhatsApp message gets picked up by intent extraction and turned into a calendar event exactly the way a plan mentioned in ordinary chat would, and WhatsApp conversations get folded into RAG memory the same way chat conversations do, so something a friend told you over WhatsApp last week can genuinely resurface later in an ordinary Memo conversation.

A real, if narrow, bug that shipped for a while and has since been fixed: incoming media messages with a caption — a photo someone sent along with a bit of text — were being read as if they had no text at all, because only plain text messages were being parsed from live traffic and the caption on a media message lives in a slightly different place in the underlying protocol. If you noticed Memo seeming to ignore what someone said alongside an image or document, that was the reason, and it's specifically what got corrected. Beyond that, the connection itself is designed to be resilient rather than fragile — reconnects happen automatically with increasing backoff if your connection drops, and history syncing is written to avoid creating duplicate messages on a reconnect — but WhatsApp linking is still fundamentally tied to a single device session the way WhatsApp Web itself is, so logging into WhatsApp Web or WhatsApp multi-device somewhere else entirely can still knock Memo's link loose, same as it would any other linked device.

10Calendars, Reminders, and Routines

There's a particular kind of tiredness that comes from being the only one who remembers to ask. You know you want to be reminded about the dentist next Tuesday, you know you'd like a weekly nudge to actually review your week, but remembering to set the reminder is itself the thing you keep forgetting to do. Memo's calendar and Routines system exists specifically to take that first step off your plate.

The calendar side works quietly, almost passively: when you mention a plan in ordinary conversation — "football tomorrow at 11 with Ahmet" — a lightweight keyword filter first checks whether the message even sounds time-bound or plan-shaped at all, without ever involving the language model, and only messages that pass this cheap first check get sent on for full extraction, where the model pulls out a title, a resolved time, and a short summary. If it looks like an event, it's added to your calendar immediately, with a notification confirming it happened rather than a confirmation prompt asking permission first — the deliberate design choice here is minimizing friction, on the assumption that a wrong auto-added event is a quick delete while requiring confirmation on every single mention would make the whole feature annoying enough that people stop using it. A reminder fires a configurable lead time before the event — 10 minutes, 15, 30, an hour, or two hours, your choice — and on mobile that reminder arrives as a real, pre-scheduled local notification, meaning it can reach you even if the app isn't open at the time you'd expect the check to happen.

Routines are the more deliberate cousin of the same idea: instead of Memo noticing a plan in passing conversation, you describe directly what you want done and how often, in plain language, and Memo turns that into a scheduled automation that fires in the background without you having to ask again. What actually happens when a routine fires depends on how you set it up — it can be as simple as a single prompt sent to a model, generating a bit of text you'll see as a notification, or it can be a full agent run with tools enabled, meaning a routine can genuinely go check something, look something up, or take an action on your behalf on a schedule, not just generate a reminder message. And because a routine's output is a real conversation turn like any other, it gets folded into RAG memory the same way — a weekly self-insight routine's summary from a month ago is something you can search back up later in an ordinary chat, the same as anything else Memo has ever said to you.

Timezones are handled per-device rather than assuming the server's own clock is authoritative: a routine captures your device's timezone at the moment you create it, and that offset now automatically resyncs every time the app reconnects, so traveling across time zones or a daylight-saving shift corrects itself going forward instead of leaving a routine permanently stuck on whatever was true the day you set it up — a real gap in earlier versions that's specifically been closed. Routine-generated text — the model's own instructions for that run, the "nothing due today" filler message, notification titles — now follows your actual language setting rather than defaulting to Turkish regardless of what the rest of the app was set to, which was a genuine inconsistency in earlier builds that's worth knowing was a real, now-fixed bug rather than something you're misconfiguring if you noticed it.

The most common confusion with both features is really the same confusion from two directions: people either don't realize the calendar is watching ordinary conversation at all, and are surprised the first time an event shows up they never explicitly asked to create — which is intentional, and the delete button exists exactly for the rare case it guessed wrong — or they set up a Routine expecting it to behave like a simple reminder when they actually want it running with tools enabled, and are confused when it produces a static message instead of actually checking something live. That toggle, simple prompt versus full agent run, is the one setting worth double-checking if a routine's output feels thinner than you expected.

11Proactive Learning, Ambient Nudges, and Self-Insight

Most assistants are purely reactive: they say nothing until you ask something. Memo's proactive layer is a deliberate, careful step away from that — the idea that an assistant which has actually been paying attention should occasionally be able to say "hey, isn't it about your usual coding time?" without you having to prompt it into noticing the pattern itself.

This runs on two tracks that move at different speeds. Something you state directly — "I code every night around 9" — is trusted more or less immediately, the same way a person believes you the first time you tell them a fact about yourself rather than needing to observe it happen repeatedly first. Something Memo only infers by watching usage over time — you happen to open the calendar every morning around nine, you tend to ask for code review on Friday afternoons — needs to actually show up statistically across a real number of sessions before it's treated as confident enough to mention, using circular statistics to detect genuine daily and weekly regularities rather than jumping at the first coincidence. That asymmetry is deliberate: a directly stated habit is a fact, a passively observed one is a hypothesis, and Memo treats them with correspondingly different levels of confidence before acting on either.

When a nudge does fire, it doesn't have to arrive as its own separate interruption — as of the current release it can also show up woven naturally into the middle of one of Memo's own replies, phrased conversationally rather than as a formal alert, and whether that nudge actually landed and whether you accepted or brushed it off is judged by asking the model itself to assess the exchange, rather than pattern-matching on specific wording in a specific language, which matters a lot for a bilingual app where the same intent can be phrased entirely differently in Turkish or English. There's also a real, visible suggestion banner on desktop now — Yes, Not now, or Stop asking — which didn't exist at all in earlier versions; before this, a pending suggestion genuinely had no UI to respond to, which made the whole feature feel more like background noise than something you could actually interact with.

The system is deliberately careful about not overstepping. It's fully disabled the moment Incognito Mode is on, and fully disabled under Minimal Mode too, unless you've specifically gone in and re-enabled it — and Minimal Mode's controls, as of the current release, aren't just an all-or-nothing switch anymore. Settings → General lets you independently re-enable persona and system-prompt behavior, capability disclosures, passive-feature disclosures, and proactive learning specifically, each on its own, even while the rest of Minimal Mode stays stripped down — useful if you want a lean, low-overhead local model experience but still want the ambient nudges specifically, rather than accepting the full trade-off as one block.

A closely related feature, /insight, is worth understanding on its own terms because it's easy to mistake for the same thing as an ambient nudge when it's actually a distinct, on-demand act. Ask Memo /insight directly, or set a weekly Routine to ask it for you automatically, and it looks back across your recent mood history and memory to describe whatever real pattern it's actually noticing — and it's explicitly instructed not to invent one where there isn't enough signal to justify it, which means the honest and correct response some weeks is simply "not enough has changed for me to say anything meaningful yet" rather than manufacturing a confident-sounding observation to fill the space. If /insight ever comes back thin or noncommittal, that's very likely the feature working as designed rather than failing — a system built to occasionally admit it doesn't know is doing something more useful, if less immediately satisfying, than one that always has a confident answer ready regardless of whether the data supports it.

12Bringing Your Memory From Somewhere Else

If you've spent months talking to ChatGPT, Gemini, or Claude before ever trying Memo, there's a real question sitting underneath switching over: does starting fresh mean losing everything that assistant already knew about you? Memo's memory-import feature is a direct answer to exactly that discomfort — a one-time bootstrap that lets you carry what another AI already learned about you straight into Memo's own memory, rather than starting from a blank slate.

The mechanism is refreshingly low-tech and doesn't require any API access to the other assistant at all. Memo gives you a prompt to copy and paste directly into whatever AI you've been using, asking it to describe you back in a structured way — your demographics, interests, relationships, upcoming plans, communication style, any standing instructions you'd given it. You copy that assistant's answer back into Memo and hit save, and Memo sends the whole thing through your own currently active model — local or external, whichever you have running — which breaks the response into individual, atomic facts and saves each one the same way a /remember command would, plus a separate summary specifically about how you like to be talked to, which gets folded permanently into Memo's own system prompt rather than sitting as just another fact competing for retrieval.

The one honest caveat worth internalizing before you try this: the quality of what comes back is entirely bounded by how much real history the other assistant actually has to draw on. If you've only had a handful of conversations with that other AI, asking it to describe you back in detail will produce a thin, mostly generic result, because there's genuinely not much for it to summarize — this isn't a limitation of Memo's import mechanism, it's just an honest reflection of "you can't extract more signal than actually exists." The feature includes a tip banner reminding you of exactly this before you start, which is worth taking seriously rather than being disappointed by a sparse result later. It fails fast and tells you plainly if nothing's connected to process the import, rather than hanging indefinitely waiting on a model that was never going to answer.

13Backup, Cloud Sync, and Restore

Local-first is a genuine promise, but it comes with a genuine risk attached: if everything lives only on one machine, a dead hard drive is also the day you lose every memory Memo ever built up about you. Memo addresses that with two complementary systems — a manual, complete export you control directly, and an optional, automatic encrypted sync to your own Google Drive.

The manual export produces a single .memo file, a zip archive containing essentially everything: your chat sessions, your configuration, your memory database, your calendar and reminders, your learned habits and any pending proactive suggestions, your routines, your agent tool permissions, your usage stats, your installed skills, and your WhatsApp data. This has genuinely gotten more complete recently, and it's worth knowing what changed if you took a backup on an older version and are wondering whether it's still trustworthy: earlier exports left out calendar events, learned habits, routines, task lists, agent permissions, and installed skills entirely — only chats, memory, provider configuration, and WhatsApp data actually made it into the archive. Worse, and more consequential, machine.key — the file that decrypts your encrypted provider API keys — was never included in the export at all, which meant restoring an old backup on a new machine, or after a full wipe, would bring your provider configuration back looking intact while every API key inside it was permanently unreadable. Both gaps are closed now: the export is genuinely complete, machine key included, with your downloaded model files themselves the one thing still excluded by default, kept optional through their own toggle since they can be many gigabytes and are trivially re-downloadable anyway. A few things are deliberately still left out on every export, and this is by design rather than an oversight: a Drive sync cursor tied specifically to the machine that created it, since replaying it on a different device could make cloud sync think changes had already been seen when they hadn't; the machine-specific Tailscale identity, which wouldn't make sense to transplant; and the backup system's own snapshot directory, since including it would mean nesting old backups inside the new one indefinitely.

Cloud sync layers automatic, encrypted backup to your own Google Drive on top of that manual export, for people who'd rather not remember to export by hand at all. You connect your Google account through OAuth, set a passphrase, and from that point forward, roughly every fifty messages, Memo quietly packages your data, encrypts it, and uploads it in the background. The encryption is genuinely end-to-end: your data is locked with AES-256-GCM using a key derived from your passphrase through PBKDF2 with 600,000 iterations before it ever leaves your machine, which means Google is storing something that, to them, is indistinguishable from random noise — they never hold the key, and there's no way for them, or anyone who compromised their servers, to read the contents. The corresponding responsibility is entirely on you: if you forget that passphrase, there genuinely is no recovery path, by design — a recoverable passphrase would mean someone other than you could get in too. If you leave the passphrase field empty rather than setting one, Memo falls back to an automatically generated machine-specific key, which works fine for encrypting backups on the same computer but, being tied to that machine's identity, can't meaningfully be used to restore onto a different one later — setting a real passphrase yourself is the only path that actually supports moving to new hardware down the line.

14The Privacy and Security Posture, Taken as a Whole

Everything described so far implies a certain philosophy, but it's worth stating directly: Memo treats privacy not as a feature to advertise but as a default posture that individual features either respect or deliberately, visibly override. A few specific mechanisms exist to make that posture concrete rather than just aspirational.

Incognito Mode is the sharpest tool for this: switch it on, from an eye icon right in the chat interface, and for as long as it's active nothing about that conversation touches disk at all — memory recording stops entirely, chat history isn't written anywhere, and the whole conversation lives only in RAM for the duration of the session, gone the moment you close it. It's built for the specific moments where you're pasting a password or a secret key into a code block, doing research you'd rather not have permanently indexed into your own assistant's memory, or just having a throwaway conversation you don't want cluttering everything Memo otherwise knows about you. Every proactive system in the app — ambient nudges, intent extraction, the observer pattern engine — is unconditionally disabled the moment Incognito is on, no exceptions and no separate toggle needed.

Minimal Mode sits alongside it as a related but distinct idea, aimed less at a single sensitive conversation and more at trimming how much Memo adds to every conversation by default — when it's fully on, personality, mood tracking, and web-search instructions are all stripped out of what reaches the model, leaving essentially just your message as typed, which matters most for people running a local model on modest hardware where every extra token in the prompt is a real cost. As covered in the proactive learning chapter, Minimal Mode's controls are granular rather than all-or-nothing now, letting you re-enable persona, disclosures, or proactive learning individually even while keeping the rest of the mode's leanness.

Remote access — letting your phone, or any other device, reach Memo's backend over your network — is the one place where "local-first" necessarily opens a door outward, and it's gated accordingly: as of a security fix in the current release, every request to a Memo instance that's been opened up beyond localhost, whether over your LAN or through an ngrok tunnel, must present the access token shown in Settings. Before that fix, anyone who could simply reach the address at all — anyone on the same Wi-Fi, anyone with the ngrok link — could read your provider API keys, wipe your entire data directory, or run agent commands on your machine with zero credentials required, which is about as serious a gap as a local-first app can have. Local-only use, the default, with remote access switched off, was never affected by this at all — the token requirement only ever applies once you've deliberately opened the door.

And the sandboxed agent from earlier deserves a second mention here specifically because it's the part of Memo most capable of doing real damage if something in its safety net were ever wrong, which is exactly why bugs found in it — the symlink-escape gap that let a file tool write outside its sandboxed directory, the word-boundary flaw that let the exact commands the blacklist existed to catch slip straight through — get treated as security issues and fixed promptly rather than filed away as minor polish. The honest framing for all of this, taken together, is that Memo is built by someone who clearly takes the security of a tool this powerful seriously, catches real problems in it, and fixes them fast once found — while also being genuinely young software where you should expect that process to keep happening, rather than assuming a permission system this ambitious was perfect on day one.

15The Mobile App and Remote Access

Memo's phone app is deliberately not a second brain of its own — it's a window onto the one running on your desktop. Every bit of actual work, the model inference, the memory search, the embedding, happens back on your computer; the phone just displays what you typed and what came back, which means it doesn't need to be a powerful device at all, won't heat up, and won't meaningfully touch your battery or mobile data doing anything Memo-related.

Getting the two talking to each other has three real shapes, depending on where you and your computer actually are relative to each other. On the same Wi-Fi network, it's the simplest case: you find your computer's local IP address, enter it plus the port into the mobile app — or just tap Scan and let the phone find Memo automatically across your network rather than typing an address by hand — and you're connected, with no internet connection required at all beyond the local network itself. Away from home, you need one of two tunnels: ngrok is the faster one to set up, free to start, but it hands you a new public URL every single time you restart it, which means updating the mobile app's connection each time unless you're on a paid ngrok plan with a reserved domain. Tailscale is the more durable option — slightly more setup up front, but once it's configured, the address you connect to stays exactly the same forever, through restarts, through your computer's IP address changing, through anything short of you deliberately reconfiguring it, which makes it the better choice if you're setting this up once and want to forget about it afterward.

Whichever path you take to reach it remotely, the calendar and Routines features described earlier work identically on mobile as on desktop, including the part that actually matters most for a phone: reminders arrive as real, pre-scheduled local notifications rather than something the app has to be open and polling to catch, so a reminder set an hour ago still reaches you even if you haven't opened Memo since. And the same remote-access token requirement covered in the previous chapter applies here directly — if you've opened Memo up beyond your local network at all, entering that token when you first connect the mobile app isn't optional, it's the one thing standing between "only you can reach this" and "anyone with the URL can."

16The Developer API Gateway

There's a particular irony in loving privacy-respecting local infrastructure while also loving the genuinely excellent coding tools that happen to be built exclusively around cloud APIs. The Developer API Gateway is Memo's answer to not having to choose: it makes Memo speak the same wire format Anthropic's own API speaks, well enough that Claude Code — or any other tool built to talk to an Anthropic-compatible endpoint — can be pointed at your own local Memo instance via ANTHROPIC_BASE_URL, and use it as if it were talking to the real Anthropic API directly.

What actually happens underneath is a genuine translation layer, not a proxy: a request arrives shaped like an Anthropic API call, gets translated into Memo's own internal representation, routed to whichever backend you've configured — your local model, or any of your configured external providers — and the response gets translated back into Anthropic's expected shape on the way out. Model selection happens through a small convention: the request's model field takes the form type/model-id, so local/qwen2.5 routes to whatever local model you currently have loaded (the model-id part there is really just a label, since the real model is whatever's already running), while something like openai/gpt-4o finds the first enabled provider of type OpenAI and uses that specific model. The part that actually makes Claude Code useful through this gateway rather than just chatty is that full agentic tool use is genuinely supported — reading and writing files, running commands, all the multi-turn back-and-forth of a real coding session translates correctly in both directions, including a subtle but important detail around how Anthropic represents a tool's input as a real JSON object while OpenAI-style APIs expect that same data flattened into a JSON string, which had to be handled exactly right in both directions for Claude Code to actually receive usable data rather than a mangled string.

This unlocks something specific for a technically inclined user: you can run Claude Code — or anything else speaking this same protocol — against your own local model, entirely offline, with zero API cost and zero data leaving your machine, or against your own OpenAI or Gemini key running behind the scenes, all without that external coding tool ever needing to know it isn't talking to Anthropic directly. It has its own dedicated screen in the sidebar rather than being tucked away inside Settings, with the base URL, the live list of available type/model-id combinations, and your access token all sitting there copy-paste ready, alongside a live log of every request passing through as it happens — genuinely useful the first time you're wiring this up and want to actually see whether a request landed and what came back, rather than digging through backend logs to find out. Both the optional API key requirement and the optional memory integration default to off; when memory integration is switched on, Memo does enrich a request with relevant facts from RAG memory before it's sent along, but deliberately never creates a visible chat session out of it — a coding session run through Claude Code this way stays entirely separate from your regular Memo chat history, by design, so the two don't get mixed up. The one real limitation worth knowing up front: tool calling through this gateway doesn't yet work for the Gemini, Claude, or Ollama provider types specifically, since their own underlying provider implementations in Memo don't support tool definitions at all yet — routing a tool-using request to one of those gets you a clear error rather than a silently broken response, at least.

Wiring it up in practice takes about a minute. Open the Developer screen, copy the Base URL (http://localhost:8090 by default), and set it as an environment variable before launching Claude Code, alongside a placeholder API key (Claude Code's own SDK insists on something being set, even though Memo won't check it unless you've turned on Require API Key) and whichever type/model-id you want it to use to start:

export ANTHROPIC_BASE_URL="http://localhost:8090"
export ANTHROPIC_API_KEY="not-needed"
export ANTHROPIC_MODEL="local/qwen2.5"

From there you just run claude as you always would — nothing about how it looks or feels changes, because as far as its own SDK can tell, it's talking to the real Anthropic API. Switching models mid-session works through Claude Code's own /model command (/model openai/gpt-4o, say), and the Developer screen's live log is the fastest way to confirm your very first request actually landed rather than silently failing somewhere between the two.

17Memo Swarm: Pooling Machines for One Big Model

Every so often a genuinely capable open-weight model comes along that's simply too large for any one ordinary machine to hold in memory at all — not "slow," but literally won't fit. Memo Swarm, still in beta, is built for exactly that specific situation, and it's worth being precise about what it does and doesn't do, because the name invites an assumption ("distributed compute, therefore faster") that isn't actually the point.

The idea: one machine, the Host, keeps the actual model file and opens a room, sharing a short room code with the other computers you want to pool in. Those other machines — Joins — never download the model at all; they only lend their own compute capacity to the Host, connecting through llama.cpp's own existing RPC mechanism rather than anything Memo invented from scratch. You set each joining machine's share by hand as a percentage, start the swarm, and if it all comes together, a model that genuinely wouldn't run on any single one of those computers alone can run across the pool of them together. The honest framing here matters: the goal is capacity, not speed — tokens across a swarm are typically slower than a comparable model running natively on one strong machine, and the entire value proposition is "this runs at all" rather than "this runs faster."

This is squarely for a specific kind of user: someone with a few underused machines at home or in a small office, genuinely interested in running something at the very top end of open-weight model sizes, who has the patience for beta software and slower tokens in exchange for capability that wouldn't otherwise be reachable on any one of those machines individually. It's tucked behind Settings → Beta Features specifically because it needs that framing — this is explicitly not yet as polished or as reliable as the rest of the app, and current limitations are worth knowing before you invest time setting it up: there's no macOS support yet at all, since the RPC helper binary simply isn't packaged for that platform currently, and every machine in the pool needs to actually be able to reach the Host over the network, which for machines outside a shared home LAN generally means an OS-level tool like Tailscale set up on both ends rather than relying on Memo's own embedded tunnel, which handles HTTP traffic but not the separate raw TCP connection the RPC layer itself needs.

18Usage Stats and the Larger Point

Tucked into Settings sits a quieter, less dramatic feature that's worth ending on anyway, because it says something about the project's whole posture: a Stats tab showing your total requests, your total input and output tokens, average tokens per second, your most-used model, and a simple daily chart of the last month's usage broken down by model. Every completed turn gets logged to it — whether it came from a local model, an agent run, Orchestra, or an external provider — with exactly one exception: Incognito Mode, which stays completely invisible to this too, the same as everything else it opts out of. One thing conspicuously absent from that dashboard is a dollar figure: no provider exposes real, reliable pricing data through its API today, and shipping a static price table that would silently drift out of date felt like a worse choice than simply not pretending to know a number nobody can actually verify.

That small, almost boring decision — leave out the number rather than fake precision you don't have — is a decent stand-in for how the whole project tends to behave. Memo doesn't try to look more finished than it is. The changelog for any given release is as likely to describe a bug fixed as a feature added, and often more so, and that's not a weakness to apologize for so much as what building something this ambitious, largely solo, actually looks like in the open, in public, version after version. What you get in exchange is software with no telemetry watching what you type, no cloud dependency deciding whether it still works tomorrow, no business model quietly nudging features toward engagement rather than usefulness — just your own machine, whichever model you choose to trust it with, local or otherwise, and a memory that's genuinely yours, exportable, deletable, and readable in a plain SQLite file whenever you want to look at it directly. That's the whole idea, really: not a product handed down to you finished, but a tool you actually own, built by someone who wanted exactly that to exist badly enough to build it himself.