What is an MCP memory server?

An MCP server that gives an AI assistant somewhere to store and retrieve information between sessions. The reference implementation keeps a knowledge graph in a local file; others like basic-memory, OpenMemory, and Graphiti's server offer richer storage. Because they speak the Model Context Protocol, any MCP-capable client - Claude Code, Claude Desktop, Cursor - can use them. They're free, open source, and run locally by default.

Is Milestone just a hosted memory MCP server?

No. It exposes a graph over MCP, so that part looks similar, but the substance is different in three ways. The memory is shared across a team rather than living on one machine. New facts an agent learns are staged for human approval before they become durable, instead of being written silently mid-session. And the graph is produced by a workspace where the team actually tracks work, so knowledge links to the task and decision that created it rather than floating on its own.

When is a free memory MCP server enough?

When the memory is genuinely yours. Solo work, one machine, personal preferences and habits, or anything that must not leave your hardware - a local server handles all of that well and costs nothing. The line is crossed when a colleague should benefit from what your session just learned, or when a wrong fact the model wrote would spread to other people rather than just annoying you.

Can I use a memory MCP server and Milestone at the same time?

Yes. MCP connections are additive, so an agent can hold both and use each for what it's good at: the local server for personal habits and machine-specific detail, Milestone for knowledge the team shares and reviews. There's no conflict, and no need to pick one before you know where your own line is.

Why does a shared memory need a review step when a personal one doesn't?

Because the blast radius is different. On a personal store, a wrong fact the model inferred costs you one confusing session and you fix it. On a shared store, that same fact reaches everyone's sessions and gets treated as settled team knowledge. Milestone stages what agents learn in /context so a human approves it first - which is slower than writing silently, and the reason a shared memory can be trusted at all.

Compare

Milestone vs MCP memory servers

Memory MCP servers - the reference knowledge-graph memory server, basic-memory, OpenMemory, Graphiti’s server and others - give an assistant somewhere to write things down between sessions. They’re free, local, agent-neutral, and a genuinely good first step. Milestone is a shared context layerfor a team, so the comparison isn’t about storage. It’s about whose memory it is and who checks it.

Updated August 3, 2026

The short version

A local memory server solves “my agent forgets between sessions.” It does not solve “my team keeps teaching four agents the same thing,” because the memory lives on one machine, belongs to one person, and nothing decides whether what got written is correct or worth keeping. If you’re working solo, start with the free server. If a colleague should benefit from what your session just learned, that’s the line.

At a glance

Milestone compared with Memory MCP servers across core dimensions
	Milestone	Memory MCP servers
What it is	A team workspace and tracker built on a shared knowledge graph	An MCP server the agent can write to and read from
Whose memory it is	The team's - shared by default, scoped where it should be	One person's, on one machine
Where it lives	Hosted (AWS US), cached locally so the app works offline	Usually a local file or database you run
Who decides what's worth keeping	The model proposes; a human approves in /context	The model, mid-session, with no review step
Structure	Typed nodes - tasks, decisions, conventions, gotchas, people, code areas	Free-form entities and relations, or plain notes
Connected to the work	Yes - knowledge links to the task and decision that produced it	No - memory is standalone, with no notion of your tracker
Humans can read it	Yes - it's the app your team already works in	Only by opening the store the server writes to
Agent-neutral	Yes - MCP, so Claude Code, Codex, and others see the same context	Yes - MCP, though each machine has its own copy
Setup & upkeep	Install the app, connect the agent	Configure per machine, per person; you run and back it up
Pricing	Free forever + Pro $12/seat/mo (free during early access)	Free and open source

Milestone pricing shown in full - see the pricing page. Memory MCP servers are free and open source; the cost is the time you spend running, syncing, and backing them up.

Start with the free server. Really.

If your agent forgets between sessions and that’s the whole problem, install a memory MCP server. It takes minutes, costs nothing, runs locally, and works with any MCP-capable assistant. Nothing in this comparison argues otherwise, and a team that hasn’t felt the limits yet should not be buying a memory layer. What follows is about the specific point where a personal store stops being the answer - which arrives sooner than most people expect, and never because you ran out of storage.

The limit is the machine, not the model

A local memory server holds what your sessions taught it, on yourlaptop. When a colleague opens their agent, it starts from zero, and the convention you established last week is invisible to them - so they establish their own, slightly different one, and now the codebase has two. That divergence is the actual cost, and it’s hard to see from inside one machine because your own sessions keep getting better. Milestone is shared by default, so what one session learns is available to the next person’s.

Nothing checks what gets written

Memory servers write whatever the model decides to write, mid-session, with no review. Some of that is genuinely useful and would never have been documented otherwise. Some of it is a wrong inference, a branch-specific detail, or something true for twenty minutes. On a personal store that’s tolerable - you’ll notice and correct it. On a shared one it’s a real hazard, because a bad fact propagates to everyone. Milestone stages new learnings in /context for a human to approve first. That gate is the price of sharing.

Memory disconnected from the work has nothing to anchor to

A memory server knows facts. It doesn’t know that this fact came out of the auth refactor, that the refactor was motivated by a specific decision, or that the decision set a convention which applies to three other services. Milestone models those links explicitly, which is what makes retrieval precise: an agent touching a file can ask for the conventions and known gotchas for that area rather than whatever is semantically nearby. Standalone memory can only match on similarity, because there is no structure to traverse.

Humans can’t read it either

This gets overlooked. The memory a local server accumulates is stored for the model’s benefit, in a file or database nobody opens. So when a new engineer joins, none of it helps them - it’s a growing store of institutional knowledge in a format no human browses. Milestone’s graph is the app the team already works in, so the same decisions and conventions the agent reads are the ones a person reads when they’re trying to understand why something is the way it is.

Where the free server is the better choice

Solo work. One machine. Personal preferences and habits you don’t want to re-type. Situations where the data must never leave your hardware - a memory server is local by default, while Milestone stores your graph on AWS in the US. And any case where you want to own and inspect the store yourself: these projects are open source, and Milestone isn’t. Those are good reasons, and none of them are about scale.

Who each is for

Choose Milestone if…

More than one person runs agent sessions on the same codebase
You want a human review step before agent-written facts become team truth
You want knowledge linked to the work that produced it, not floating
You want teammates and new joiners to be able to read it too

Stick with Memory MCP servers if…

You're working solo on one machine
The data must stay on your own hardware
You want an open-source store you run and inspect yourself
Personal habits and preferences are the whole problem

Moving from Memory MCP servers

Nothing forces a choice here - MCP connections are additive, and an agent can talk to a local memory server and to Milestone at the same time. In practice the local store keeps doing personal work (your habits, your machine) while anything the team should share moves to the layer that reviews it. Milestone doesn’t import from memory servers today; given most of what accumulates in them is personal and unreviewed, starting the shared graph clean is usually the better outcome anyway.

Questions

What is an MCP memory server?: An MCP server that gives an AI assistant somewhere to store and retrieve information between sessions. The reference implementation keeps a knowledge graph in a local file; others like basic-memory, OpenMemory, and Graphiti's server offer richer storage. Because they speak the Model Context Protocol, any MCP-capable client - Claude Code, Claude Desktop, Cursor - can use them. They're free, open source, and run locally by default.
Is Milestone just a hosted memory MCP server?: No. It exposes a graph over MCP, so that part looks similar, but the substance is different in three ways. The memory is shared across a team rather than living on one machine. New facts an agent learns are staged for human approval before they become durable, instead of being written silently mid-session. And the graph is produced by a workspace where the team actually tracks work, so knowledge links to the task and decision that created it rather than floating on its own.
When is a free memory MCP server enough?: When the memory is genuinely yours. Solo work, one machine, personal preferences and habits, or anything that must not leave your hardware - a local server handles all of that well and costs nothing. The line is crossed when a colleague should benefit from what your session just learned, or when a wrong fact the model wrote would spread to other people rather than just annoying you.
Can I use a memory MCP server and Milestone at the same time?: Yes. MCP connections are additive, so an agent can hold both and use each for what it's good at: the local server for personal habits and machine-specific detail, Milestone for knowledge the team shares and reviews. There's no conflict, and no need to pick one before you know where your own line is.
Why does a shared memory need a review step when a personal one doesn't?: Because the blast radius is different. On a personal store, a wrong fact the model inferred costs you one confusing session and you fix it. On a shared store, that same fact reaches everyone's sessions and gets treated as settled team knowledge. Milestone stages what agents learn in /context so a human approves it first - which is slower than writing silently, and the reason a shared memory can be trusted at all.

Related comparisons

See it on your own project.

Join the design-partner program - free during early access, and we’ll set the MCP connection up with you.

Free during the design partner program · no card required · we only email you about early access.