Trying Meta's Muse: Architecture and Security Mechanism
I first heard about Muse when it was announced. But it came from Meta, which has not stood out in the LLM space, so I assumed it could not be that revolutionary and left it alone for a while.
Then, over the following days, I kept seeing reports that it had hit No. 1 on the app stores in the US and Japan, along with plenty of posts about it on X. Maybe something big was going on. I also used to work at Facebook (now Meta), so between that connection and plain curiosity, I installed it.
This post covers my impressions after about two weeks of use, and what I learned about its internal structure and safety design from the official posts and from asking Muse itself.
What it is like to use
I am still exploring what to hand over to it, but compared with other chat apps, the UX is very close to a personal assistant. Two points stand out.
The first is that memory is shared, to a degree, across the main chat and the side chats. As far as I know, ChatGPT, Claude, and Gemini have no concept of a main chat. But if you design the product as one assistant, a main chat is a natural setup. Other apps also share memory between chats, but in my experience it was vague and never quite scratched the itch. In Muse, things I said in other chats come up in conversation quite naturally.
After using it for a bit, I read Meta’s announcement, How We Designed Muse. My guess was roughly right. Muse is built around one long main chat, so you keep talking to the same counterpart. The original idea was to handle every conversation there, but according to the post, “In early testing, some people still wanted separate context for certain topics,” so side chats were added. The post also says memory persists across conversations, and that you get “Memory files, which you can read and edit directly.”
I wondered how this memory actually works, and Muse explained a good part of it when I asked. I cover that in the “Internal structure” section. The security post published the same day, How We Built Safety Into Muse, goes into a lot of detail too, so safety gets its own section.
The second point is that a dedicated Linux environment (in the official description, a dedicated Linux VM) runs behind the scenes for each user, so I can hand over all kinds of work. It handles email and calendar, and also shell and cron. For the browser, I can watch the screen on my phone like a remote desktop and take over, for logins for example. In the UI you can customize the agent’s system prompt through Soul.md and Identity.md, which looks borrowed from OpenClaw.
So how is it different from OpenClaw or Hermes Agent? Beyond the UX above, after reading the post I mentioned, my understanding is that the big differentiator is how much Meta invests in security. The safety section below covers that.
The connectors are rich too. For now I have it organize my daily schedule through Google Calendar, and I ask it for reminders on habits I want to build. The personalized news and weather that arrive every morning are often things I actually want to know, which is handy. For work that needs deep thinking, I still send it to Claude or Codex, because I care about model quality.
Internal structure
From here I organize how it works inside. I try to keep what is stated officially, what Muse itself told me, and what third parties have observed clearly separate.
Beyond what the UI shows, I learned a lot by talking to Muse itself. Reportedly, the home directory holds files like these:
AGENTS.md,SOUL.md,IDENTITY.md: operating rules, personality and tone, name and characterUSER.md,MEMORY.md,PROACTIVE_PREFERENCES.md: the user’s profile, the starting point of the long-term memory described below, and what to notify me about and when
Raw conversation data is stored in per-session log files and a database. From that, Muse periodically organizes memory into a memory/ folder. During a conversation it mostly consults this memory, and sometimes the raw data in the database as well.
memory/ has daily files named YYYY-MM-DD.md, where Muse extracts claims, the unit of memory, from the raw data as a list. A claim is a fact, preference, decision, or commitment that fits in one sentence, like “deliver the morning briefing in Japanese.” Each one carries an importance score, and each is also entered in a search index. Pulling a list of claims out of raw data reminded me of GraphRAG. There are also subfolders by viewpoint, such as people, groups, docs, dreams, and config. Those are not collections of claims but text organized into chapters. The subfolders seem to be created dynamically, which felt like LLM Wiki and OKF.
For how it picks up what was said in another chat, the main chat’s system prompt that Muse handed me describes two procedures: searching the shared long-term memory, and reading the chat history directly. The reason given for the second one was that each chat keeps its own history, and recent work may not be in the shared memory yet.
I also read a more detailed investigation by someone else. It describes a process that checks new claims against the original messages every hour, and a nightly “dream” process that reviews recent conversations and writes notes for future behavior. An AI dreams at night and tunes tomorrow morning’s behavior. My dreams are nowhere near that productive. Muse also told me a daily skill review runs too. As someone who builds agent harnesses myself, I find all of this useful.
Safety design
The official security post starts from assuming the agent “may be under attack” and limiting the damage. Its basis is what Simon Willison named the lethal trifecta: an agent with access to private data, exposure to untrusted content, and a way to communicate externally is easy to attack. The typical case is an email whose body says “send the personal info outside.” As countermeasures, Meta stacks model training, a harness that labels external input as untrusted, and an ensemble of prompt injection detection classifiers. I was surprised they start from model training. That could be a hard-to-copy differentiator.
The VM assigned to each user has two layers inside: the runtime cell, which the user and the agent touch, and security-sensitive services outside it, which they do not. The runtime cell holds the agent harness and working files. The services outside hold Sentinel (the sole permission authority, more below), authd (credential storage and surrogation), and the prompt injection classifiers. The runtime cell is expected to process untrusted data, so even if the agent is taken over, it cannot reach the second layer.
The split is done with systemd-nspawn. I admit I had not kept up with this one. My understanding is that, like Docker, it builds an isolated environment with namespaces and cgroups, basically a stronger chroot. The cell gets its own root filesystem, separate from the host, and by design sensitive things like credentials are kept out of it in the first place. The post says: “Root inside the runtime cell is mapped to an unprivileged host user.” The two sides talk over Unix sockets, and only authenticated processes can communicate. The cell also gets filtered system calls and limited kernel capabilities.
Sentinel acts like a firewall for anything leaving the runtime cell. It sits in the network path and can evaluate the destination hostname, IP, and port, plus the protocol, HTTP method, path, and the decoded request, at both layer 4 and layer 7. Credentials are guarded at the same checkpoint. What the agent gets is a surrogate token, not the real one. Only for permitted requests does Sentinel swap in the real credential at the network boundary, and a separate service manages the real ones. In the post’s words: “Muse proposes actions, but only Sentinel can grant permission to perform action.”
Alongside Sentinel there is kernel-level data flow tracking, which Meta calls “tainted egress.” Each tool execution process starts out in a clean state, and once it reads user data such as emails or files, it becomes “tainted.” This is built on eBPF, which lets you hook small programs into the Linux kernel to monitor and control network traffic and process behavior. A tainted process loses auto-allow and falls back to the normal approval flow, so anything it sends out needs the user’s approval. In the email example, once the body has been read, the process can no longer send things out on its own. So even if the email says “send the personal info outside,” it is hard to leak anything without the user’s approval.
For the browser, login input goes through a dedicated UI, which the user operates from the app like a remote desktop. As a safeguard, the browser sub-agent cannot run JavaScript in the page, and “Chrome devtools are disabled.” The CDP (Chrome DevTools Protocol) connection is handled by a broker outside the runtime cell. The sub-agent sees the page as an accessibility tree, so it cannot read the credentials you type from the DOM.
On top of this, Meta runs a public bug bounty. Reading it showed me how seriously Meta takes security, which I could not have told from using the app alone. It is a reminder that primary sources are worth reading.
Wrapping up
I only meant to try it out of casual curiosity, and yet I came away with plenty that will help with knowledge accumulation and agent-harness design. It was a good reminder not to dismiss trendy technology before trying it.
Now I am taking lessons from an AI that tunes itself in its sleep. I had better get to work.
Related: Rethinking the Knowledge Base: Maybe Just Start with an LLM Wiki?; Agentic Development: How to scale it?
Comments (0)
No comments yet. Be the first!