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 forty iterations before it has to stop and give you a final answer, across 27 built-in tools now rather than the original handful.

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.

05Code Mode: Three Gears Instead of One Switch

Agent Mode is powerful precisely because it doesn't ask permission for the boring parts, but "how much doesn't it ask permission for" turns out to matter a lot depending on what you're actually doing at that moment. Reading through an unfamiliar codebase and writing something like it are genuinely different activities that want different amounts of caution, and as of the current release Memo stopped pretending they're the same thing with a single on/off Agent toggle. Code Mode is now three distinct gears — Plan, Auto, and Build — cycled with Ctrl+Tab in the message box, or a tap on the chip that now lives in the bottom status strip.

Plan is the most cautious of the three, and deliberately so: it investigates, reads, greps, follows a codebase's own logic to understand what a change would actually require — and touches nothing. What it produces instead is a real, saved plan, written to disk rather than left to scroll away in the chat history, and once it's finished, Memo asks you directly, in plain language, whether to move on to Build or stay in Auto. Auto is the gear that's been here all along — the same file-edits-ask-first behavior Agent Mode has always had. Build is the one that trusts you've already reviewed the plan: file edits and shell commands run without a confirmation prompt in between, on the theory that if you've read the plan and you're telling it to build, stopping to ask about every individual edit inside that plan is friction without a corresponding safety benefit. If you've turned on the global auto-permission mode described above, the hand-off is even more seamless: a finished plan chains straight into Build automatically, in the same reply, without waiting for you to answer the question at all.

Each of the three gears has its own system prompt behind it, and — like Memo's main persona prompt — each one is editable from Settings if the defaults don't match how you actually work. One honest caveat, specific enough to be worth flagging directly: the automatic hand-off from a finished plan into Build depends on a system-role message existing in the conversation, which local llama.cpp models don't currently get (the instruction folds into the user's own message instead) — so on a local model, Plan mode still falls back to asking you directly in chat rather than silently skipping the question, which is the correct and intended behavior, just not yet the fully automatic one.

06The Self-Driving Task Loop: Hand It a Checklist and Walk Away

There's a category of work that doesn't really need a conversation so much as it needs someone to actually go do it — a list of ten small fixes, a migration that touches thirty files in the same predictable way, a checklist you'd normally work through yourself one item at a time while glancing at your phone between each one. The Self-Driving Task Loop is Memo's answer to that specific shape of task: you hand it a Task.md file — a plain checkbox list, the same format you'd write by hand in any editor — and it works through the items unattended, checking each one off as it actually gets done rather than as you'd like it to be done.

For anything nontrivial, it's worth turning on planner mode rather than diving straight into execution: set the right header in the Task.md file and, before touching a single item, Memo produces a Plan.md of its own — concrete steps, a way to check each one actually succeeded, and a dependency graph showing what has to happen before what — which you approve once, from the Tasks tab, before the loop is allowed to start moving. A large or obviously parallel item doesn't have to run as one long, uninterruptible turn either: it can spin up to three sub-agents, one dedicated coder that actually writes the change, and up to three more read-only reviewers — an analyzer, a reviewer, a test-runner — running genuinely in parallel and feeding their findings back into a single chief review before the item gets marked done.

What actually makes this trustworthy enough to leave running in the background, rather than something you have to babysit anyway, is how it fails. A busy chat gets queued and retried instead of having its task killed outright. A rate-limited provider waits it out and resumes from the exact same item rather than restarting the whole list from the top. A genuinely transient failure gets an escalating retry — five minutes, then ten — before the item is finally parked for you to look at by hand. And every terminal state, good or bad, actually tells you: a chat message, a push notification, never a task that quietly stopped somewhere in the middle with no explanation for why. You can pause a running task from chat with a plain instruction and pick it back up later from the exact step it left off on, carrying forward anything you typed while it was paused. The one honest limitation worth knowing going in: the model running your regular chat can't yet reliably answer "how's that task going" for one that's actually mid-run without some risk of confidently making something up rather than admitting it doesn't know — a tool exists now specifically to close that gap, but it hasn't been exercised enough in the wild to call it fully proven yet.

07The Desktop Mascot: A Face for What Memo Is Doing

Most of what Memo does happens invisibly — a tool call here, a memory search there, a background retry nobody sees unless something goes wrong. The desktop mascot, new this release, is a small, deliberate exception: a genuinely separate window, its own always-on-top little character living on your desktop outside the chat window entirely, whose entire job is to make Memo's actual activity legible at a glance instead of leaving it to disappear into logs.

It isn't a second app pretending to be lightweight — it's a real second window inside the exact same running process, sharing the same state and the same lifecycle as the rest of Memo, which took an honest architectural detour to get right: the very first version of this feature really was a second binary entirely, and while it technically worked, it doubled the app's memory footprint and never quite felt like it belonged. What you get instead is one app-wide signal — whatever Memo is doing right now, across every surface, whether that's an ordinary chat reply, an agent tool call, or a Self-Driving task turning over in the background — that the mascot polls and reflects, live, in its pose: thinking, writing, visibly working through a specific named tool, and, when a turn actually finishes, an unmistakable little "arms up" moment with a bubble that says "Completed!" for a couple of seconds before it settles back into an idle stance. Left alone, it isn't just standing there either — it blinks, it breathes, and every so often it'll throw in an unprompted wave or a small hop, the kind of detail that exists purely so the thing reads as alive rather than paused. Pick between two skins from Settings, with a live preview of each before you commit: the original hand-drawn creature it launched with, or a newer blue-navy pixel-art robot running on the exact same animation system underneath. And if you're in a Live Mode voice conversation, it actually opens and closes its mouth in time with what's being said, with its own small "Speaking…" bubble — the one state it deliberately doesn't attempt is a "listening" pose, because neither voice engine it can run on today actually reports back a real listening signal for it to reflect honestly, and the honest choice was leaving that one out rather than faking it.

08Live Mode: A Real Spoken Conversation

Typing works, but sometimes what you actually want is to just talk — hands full, walking somewhere, or simply preferring to think out loud rather than compose a message. Live Mode is Memo's answer, and as of this release line it's a genuinely different thing than an earlier, cruder version of the same idea: this is native audio-to-audio conversation through Google's Live API or OpenAI's Realtime API, the model hearing and speaking sound directly, rather than a chain of separate speech-to-text, chat completion, and text-to-speech steps stitched together and hoping the seams don't show.

A small voice icon sits right next to the chat input box — not a separate screen you have to go find — and from there you can run a Live Mode conversation two ways: as its own standalone session, or delegated into a chat you're already having, so the two genuinely share memory and context rather than starting cold. Barge-in works the way a real conversation does: start talking again while Memo is still speaking, and it stops to actually listen instead of talking over you. And unlike the version of voice this replaced, memory context now refreshes mid-conversation rather than being fetched once at the very start and then frozen — so something you mention ten minutes into a long spoken conversation can genuinely inform what Memo says a few exchanges later, the same way it already worked in text chat.

If you haven't configured a native voice engine at all, Live Mode doesn't simply stop working — it falls back to the original approach: on-device transcription feeding a normal chat turn, with the reply read back by a local, offline Piper voice, or an external ElevenLabs or custom TTS engine if you've set one up. And when something does go wrong starting a session, it says so now rather than leaving you talking to what sounds suspiciously like your own echoed-back voice with zero explanation — a missing engine selection, an incomplete configuration, a background chat session that failed to open all surface as an actual, specific reason rather than a silent, confusing fallback. The one limitation still worth knowing honestly: there's no echo cancellation yet, so speaking through your computer's own speakers rather than headphones can occasionally make Memo think its own voice is you interrupting it.

09Orchestra 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.

10External 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 sixteen different provider types in total: OpenAI, Anthropic's Claude, Google's Gemini, xAI's Grok, Groq, OpenRouter, a local Ollama instance, OpenCode's two gateways, Kilo Code's AI Gateway, a pair of generic Custom slots for anything speaking either OpenAI's or Anthropic's own wire format, the Claude Code and Codex CLIs run as subprocess providers rather than API calls, and — newest of the group — gemini-sub, which lets you sign into a personal Google account and reach Gemini through Google's own Code Assist endpoint on your existing AI Pro or Ultra subscription quota rather than a separate, metered API key (still Beta — a live test found the free tier of that subscription path currently rejected by Google's own client check, so a paid AI subscription is the path that's actually been confirmed working). 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. The gateway-style providers — OpenRouter, Kilo Code, and OpenCode Zen — are friendlier here than typing a model name from memory: their dialogs fetch the real live catalog from each API and let you pick from it, with free models sorted to the top under a green checkmark (Kilo's endpoint doesn't even require a key to browse). The same screen is where per-model reasoning-effort control lives when a provider genuinely supports it — and hides itself when it can't be verified, since sending an effort level to a model that doesn't accept one is a hard request failure, not a silent no-op.

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.

11Local 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.

12The 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. Two newer inspection flags are worth knowing for scripting: memo -chat <id> -list prints an existing chat's message history from the terminal, and memo -chat <id> -memory usage reports how many memories were injected per message — deliberately refused with an explanation if you ask it the one question today's data model can't answer honestly (which memories a specific chat saved).

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.

13WhatsApp 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.

As of v3.9.0, though, the bridge grew into something more interesting than a management surface: message yourself on WhatsApp — the "Message Yourself" chat — and Memo picks it up and replies, through a dedicated background session running the same memory, intent, and mood pipeline as desktop chat, without ever hijacking whatever conversation is open in the UI. Agent tools and web search are always available in this conversation; a native "typing…" indicator shows while a reply generates; and a set of slash commands (/new, /agent, /web, /auto-perm, /status, /help) means you can steer Memo from your phone with the app itself never open. This is opt-in and off by default, deliberately — it's the one WhatsApp feature that sends outgoing messages autonomously rather than only reading or acting when explicitly told to. It also shipped with its own hard-won lesson: WhatsApp's newer @lid addressing meant the self-chat was invisible to the original matching logic for real accounts, which is exactly the kind of thing only live testing catches.

Routines connect directly into this: "every day at 9am send me the latest AI news" typed into your own chat creates a real scheduled automation — no Routines tab required — backed by three agent tools (create_routine, list_routines, cancel_routine). One security rule is absolute here: delivery targets are never chosen by the model. A routine created from your self-chat delivers to that same chat; another connected channel is added only if your text explicitly asks for it and it's actually connected. The model can never message someone else on your behalf through a routine, no matter how the request is phrased.

14Telegram: the Same Idea Through a Bot

Telegram support works on the same principle — talk to Memo from your phone — but through Telegram's official Bot API rather than account linking, which shapes what it is and isn't. You create a bot once with @BotFather, paste its token into Settings → Telegram, and send it a first message; whoever does that becomes its permanent owner, and every other account is silently ignored forever after — a stranger who finds the token gets nothing back, not even a "private bot" notice. That owner lock is the whole security model, built in from day one, because a bot token is reachable by anyone who has it.

Once connected, it behaves like the WhatsApp self-chat assistant: same background session, same memory pipeline, agent tools and web search always available, same slash commands, replies following your UI language setting. Routines work here too, under the same never-model-chosen delivery rule. The deliberate scope difference: a Telegram bot can only see messages sent to it directly, so this is purely a chat interface — there's no equivalent of reading or sending messages in your other conversations, and no telegram_send tool yet. If you want full-account visibility, that's the WhatsApp bridge; if you want the lightest possible setup with no QR code and no second linked device, the bot wins.

15Calendars, 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, in earlier versions, they set up a Routine expecting it to actually check something live and got a static message instead, because a one-shot text classification made at creation time decided whether the routine ever got tool access. That classification gate is gone entirely as of v3.9.0: every routine now runs through the full agent pipeline with web search available regardless of how its description reads, while genuinely dangerous tools (commands, file writes) still respect the routine's auto-approve setting and the live permission-ask flow. Routines can also be created, listed, and cancelled straight from WhatsApp or Telegram without touching the tab at all, as described in those chapters.

16Proactive 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.

17Bringing 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.

18Backup, 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.

19The 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: every request to a Memo instance that's been opened up beyond localhost, whether over your LAN, an ngrok tunnel, or a self-hosted server (see below), must present a credential. As of v3.5.5 that's grown from a single shared token into a real system with four selectable modes — none, token, password, or token-plus-password — with the credential-less exemption narrowed specifically to requests that genuinely originate from the same machine's own loopback interface, not just anything claiming to. Before the original v3.3.3 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 any of this — the auth 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. Skills, Memo's small plugin-style extensions, got the same treatment this release: Memo still automatically picks up a skill sitting in another tool's skill folder — Claude Code's, for instance — the moment it's discovered, but a newly-found skill used to activate itself instantly on discovery, handing it real system-prompt authority over your conversations before you'd ever looked at what it actually did. It's still discovered and copied the same way; it just waits for you to switch it on now, the same as a skill you installed by hand always required. 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.

20The 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, one honest distinction is worth knowing as of v3.9.0: calendar reminders still arrive on the phone as real, pre-scheduled local notifications — set once, and they reach you even if you haven't opened Memo since — but routine delivery to the phone no longer exists at all. The old mechanism (the app polling for an upcoming routine to pre-schedule its notification) was removed outright, because there's no actively used mobile app to receive it and the endpoint would just sit there returning nothing. Routines didn't lose their delivery channel so much as move it: they're created, listed, cancelled, and delivered through WhatsApp or Telegram self-chat instead — surfaces that are genuinely in your pocket. And if what you actually want is Memo on a phone screen without installing anything, the self-hosted web UI is fully mobile-responsive now: below phone width the whole navigation folds into a hamburger drawer, verified down to 375px in both themes. The same remote-access credential requirement covered in the previous chapter applies here directly — if you've opened Memo up beyond your local network at all, authenticating when you first connect isn't optional, it's the one thing standing between "only you can reach this" and "anyone with the URL can."

21Self-Hosting: Running Memo on a Server

Everything described up to here assumes Memo's backend lives on the same desktop or laptop you're sitting in front of, with your phone reaching out to it. As of v3.5.5, that's no longer the only shape the backend can take — it can just as easily run unattended on a Raspberry Pi, an old laptop repurposed as a home server, a NAS, or a VPS, with nothing but a network connection and, for the install itself, one line typed over SSH.

There are two real paths in. A dedicated server-only installer (get-memo-server.sh, with a beta-channel sibling for trying new self-hosted features before they land in a tagged release) pulls down the exact same release archive the desktop installer does, but deliberately skips the Flutter binary, its assets, and the app-menu entry — what you get is the backend, the memo CLI, and the local-inference engine, nothing that assumes a screen exists. It auto-detects Linux x86_64, Linux arm64, and macOS from the same command, and offers to set itself up as a systemd --user service on the way, complete with loginctl enable-linger so it survives a reboot with nobody logged in. The other path is a Docker image — multi-arch, published automatically to GHCR on every push — which is the natural fit if you're already running CasaOS, Unraid, Synology, or any other Docker-centric home-server setup; CasaOS specifically can install it straight from a pasted docker-compose.yml through its own "Install a customized app" flow. Both roads lead to the identical backend code running underneath, so nothing about memory, providers, or any feature described elsewhere in this guide behaves differently depending on which one you picked.

Once it's reachable off of localhost, the authentication story from the previous section is what actually stands guard, and self-hosting is where its fuller shape becomes worth knowing in detail rather than just in passing: four modes (none, token, password, token-plus-password), passwords hashed with argon2id and rate-limited against brute-force guessing, per-device tokens that are hashed at rest and individually revocable without touching any other device's access, and sessions that last 12 hours by default or 30 days if you check "remember me." Self-hosted Memo also gained real multi-account support alongside this — admin and user roles, managed from Settings → Accounts — so a household or small team sharing one backend isn't stuck behind a single shared login the way earlier versions effectively forced. And as of v3.9.0, "user" stopped being one fixed bundle: an admin can now grant each account access one switch at a time — Models, Memory, Agent, Calendar, WhatsApp, Telegram, Routines — with nothing checked meaning chat-only. This fails closed for restricted accounts but fail-open everywhere else (local desktop use, admin sessions, installs with no accounts configured), it's enforced server-side rather than merely hidden in the UI, and Memory is deliberately the strictest of the seven: denying it blocks reads too, so a restricted account can't see what's in shared memory at all, not merely add to it.

The part that makes any of this practical on a box you only ever reach over SSH is that the memo CLI grew into a genuine management tool rather than staying just a chat client: memo remote handles auth mode, device tokens, and — new in v3.9.0 — accounts themselves (list-accounts/add-account/delete-account, with the same comma-separated --perm list the Settings dialog's checkboxes back), memo service wraps the systemd unit (install, restart, status, uninstall), memo provider configures an external LLM provider without ever touching the REST API by hand, memo agent toggles tool-use mode and its auto-permission switch, and memo model can search Hugging Face, download a GGUF file with a live progress bar, and start it as your chat or embedding model — meaning setting up local memory on a headless box that's never had a browser open on it doesn't require a single manually-crafted curl request anywhere in the process. Anywhere a command wants a password or API key, leaving the flag off gets you an interactive, hidden prompt instead of typing it in plain sight where ps or your shell history would remember it for you.

Worth being direct about what isn't finished yet, in keeping with this guide's habit of not overselling: there's no built-in TLS, so anything meant to leave your own LAN should sit behind Tailscale, ngrok, or a reverse proxy you control rather than being exposed on plain HTTP directly to the internet; starting or stopping a Tailscale or ngrok tunnel itself is still a Settings-only action, not yet something the CLI can do; and while the auth system has been tested live — including against a real non-loopback client reaching a real Raspberry Pi over the network — a genuine adversarial security review of a self-hosted deployment specifically hasn't happened yet. Treat this as beta-hardened self-hosting, built and fixed against real installs on real hardware rather than just imagined in code, but not yet independently audited.

22The 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. As of v3.9.0 it also speaks the OpenAI-compatible shape (/v1/chat/completions, /v1/models) through the same auth, routing, and memory pipeline, so tools that only understand that format work too; there's a configurable system prompt applied additively to every gateway request; and connecting Claude Code itself is a single toggle in Settings that writes the environment into the CLI's own settings file — with your prior values backed up and restored exactly on disconnect.

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 Ollama provider type specifically, since its own underlying provider implementation in Memo doesn't support tool definitions at all yet — routing a tool-using request to it gets you a clear error rather than a silently broken response, at least. Gemini and Claude used to be on that same short list; both gained real tool-calling in an earlier release and now round-trip it correctly.

One security fix worth knowing about if you set this gateway up before the current release and left "Require API Key" switched off, which is its default: that setting used to only actually gate the Anthropic-shaped endpoint, leaving its OpenAI-compatible sibling reachable by literally anything else on the same machine or network with zero credential required, using whatever provider you'd configured, for free, without your knowledge. Both endpoints now enforce the key identically for any caller that isn't genuinely on this machine's own loopback interface — if you're running this with remote access on, it's worth confirming the requirement is actually switched on rather than assuming the default ever protected you here.

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.

23Memo 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.

24Usage 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.