The problem has grown beyond one chat app forgetting you. The agents around you now start from different files, different tools, and different context.
One repo has an AGENTS.md. Another tool reads CLAUDE.md. Hermes has a soul, Codex has a profile, OpenCode has instruction files, and a browser agent has whatever you pasted into the current run. A multi-agent runner might launch a reviewer, an implementer, and a writer in the same hour. They can all help, but they rarely start from the same memory, the same identity, or the same rules.
v0.9 adds the missing layer around that work: Skills for the methods you actually use, AI Profiles and Rules for long-running agents, and Plus for people who do not want to bring their own model keys or run their own tunnel.
The Context branch in Nowledge Mem Tree
Skills: your experience becomes capability
Remembering what you said is the easy part. The more useful thing is how you work, especially the small step you learned the hard way and now barely notice yourself doing.
Skills are our first pass at capturing that.
A Skill is a way of doing something that came out of your actual work and can be handed to an agent later. The useful ones are usually small: an order of operations, a safety check, a release gotcha, a review habit, a debugging move. Every Skill starts from something you actually did and stays off until you turn it on. One agent learns it, and the rest can use it.
Skills in Nowledge Mem
The example that stuck with us came from our own work. While building Skills, Mem noticed a method we kept using: make an evaluation that can fail, write down what happens at each step, fix the one step that is actually stuck, and leave unproven edits out. It wrote that method as a Skill. Later, the improvement loop tried to sharpen it, ran two rounds, and kept nothing because no version beat the original. That mattered more than another automatic rewrite. Once a Skill is on, an agent really follows it, so a weak change should not ship.
We wrote more here: Don’t turn Skills into a prompt library.
Every agent gets an identity
When several long-running agents work for you, identity gets messy fast. Today it is mostly scattered startup files, no shared identity model, and no clear record of who did what.
v0.9 gives each agent a name and a lane. You can name the agents that run for you, a reviewer, a research agent, a writer, a release helper, and give each an AI Profile: who it is, what it is good at, which space of memory it works in by default. You set their Rules: standing behavior that should shape every run, some global, some for a single agent, some scoped to a space. “Use concise answers.” “Do not rewrite generated API docs.” “The reviewer checks tests before approving.” Before an agent starts, it reads a Context Bundle that tells it who it is, which rules apply, and whose memory it is working on.
AI identities in Context
Standing rules in Context
This is the home for the files power users already keep by hand: the AGENTS.md, the CLAUDE.md, the Codex profile, the Hermes SOUL.md. Instead of a private prompt file per tool, every connector can ask the same question: what should this agent know before it starts? It matters most when agents move around. A reviewer might run in Codex today and inside an orchestrator tomorrow. The tool can change; the agent identity should not.
Mem also separates where work came from from who did the work. “This came from Codex” is a different fact from “this was done by my long-running reviewer agent.” Once several agents write into the same memory system, that distinction matters.
Mem keeps rule changes explicit. It can suggest candidate Rules from repeated behavior, but profiles and rules stay reviewable and editable. What takes effect is what you accept or write.
Nowledge Mem Plus: built-in AI credit and Nowledge Link
Everything above works locally, with your graph staying on your machine. But many people do not want to bring their own model keys, configure providers, or set up a tunnel just to reach Mem from a cloud agent, phone, or second machine.
That is what Nowledge Mem Plus is for:
- Nowledge AI credit, so you do not wire up models and keys yourself
- a managed Nowledge Link host: a stable remote address your cloud agents, phone, and other machines can reach, with no domain or Cloudflare tunnel to run by hand
- usage history and top-ups, with clearer account state
Nowledge Mem Plus plan settings
Nowledge Link included with Plus
Your graph stays on your machine. Plus adds subscription services around your local Mem: built-in Nowledge AI credit and a managed remote address through Nowledge Link. It saves you from bringing your own model keys or running your own tunnel; the memory graph still belongs to you. v0.9 also includes the account refresh, Nowledge AI retries, usage visibility, and subscriber alerts needed to make that plan reliable.
We are keeping Lifetime Pro too. The early Lifetime price was for private alpha supporters; as Mem moves toward GA, subscription becomes the easiest default and Lifetime pricing will not stay at that early-supporter level forever. The buy-once local option stays.
Under the hood: the memory itself got sharper
Two quieter changes make the graph more useful to every agent above.
Typed memories. Each memory can now say what kind of knowledge it is: fact, preference, decision, plan, procedure, learning, context, or event. These types change how Mem can use the memory later. A decision can supersede a plan, a learning can explain why an approach failed, and a procedure can become a Skill. The procedure path is the one to watch: before v0.9, reusable how-tos were often buried in generic memories, searchable but not reliably actionable. Existing graphs can improve these types without rebuilding the search index.
Memory links. You can now connect one memory to another inside a space, with a relation name you choose and a short reason. Version history still belongs to EVOLVES, and entity relationships still belong to the entity graph. Memory links add the semantic connection you want your own memory graph to carry. A space decides the lane of context. A Memory Link says why two memories in that lane should travel together: the pricing assumption behind a launch plan, the migration risk for an implementation, the concrete example that makes a rule usable. For an agent, that explicit human or agent-authored edge is stronger than a nearest-neighbor guess. It says: when you read this, bring that too, and know why.
Connected tools start by reading context
This release also changes how integrations use Mem. The old first move was Working Memory or search, useful but not the whole startup state. In v0.9, capable connectors read Context Bundle first, then fall back to Working Memory on older servers. The order is simple: read the startup context, understand identity and rules, search deeper when the task calls for it, then write durable decisions and procedures back. This matters most on servers and VPS installs. If Mem is running headless, the GUI cannot be the only control surface, so the same capabilities live in the API, CLI, MCP, and web client.
Try this first
If you are new to Mem, connect one AI tool, save one real decision, then ask another tool to recall it.
If you already use Mem, open Context and see what your default agent receives before it starts. Create one agent profile for a real role, give it a space, and add one standing rule that should apply every time. Then open Skills, find one suggestion you actually recognize, and if it has a source and a specific rule, turn it on.
Mem began as memory inside one AI tool. v0.9 expands it into a larger layer: the way you work, the identity of each long-running agent, the rules they should follow, remote access, and built-in AI credit.
Upgrade Nowledge Mem, and connect the next agent you use. For details, see the full changelog, Context docs, Memory Links docs, and pricing.