I built a memory layer for AI assistants that refuses 80% of what you tell it

Filippo Pilotta — Sun, 06 Sep 2026 06:18:49 +0000

Every AI assistant now has some kind of memory. ChatGPT remembers that you like short answers, Claude can read a memory file, and there is a growing list of memory APIs you can plug into an agent. After using several of them for my own work I ended up building my own, and the design decision that matters most is one that sounds wrong at first: the memory should say no most of the time.

Why storing everything fails

A memory that accepts every write behaves like a notes app nobody ever cleans. In the first week it is wonderful. By the second month, recall returns four versions of the same fact, three of them stale, and the assistant picks one with full confidence. The failure is not retrieval quality. It is that nothing ever decided whether the fact was worth keeping.

Human memory does this filtering for free. We forget almost everything and keep what was surprising, useful or repeated. Software memory has to be told to do it.

What a quality gate looks like

In Cortex, the service I built, a write is a proposal, not a command. Before anything reaches storage, the proposal is compared with what the memory already knows. If it adds nothing, it is rejected, and the client is told why. On my own instance, which holds more than 11,000 memories written by a few dozen agents, about 80% of proposals are rejected as redundant. Rejected proposals do not count against quota, which matters because it removes any incentive for a client to write less.

The rejection is not exact-match deduplication. Two sentences can be worded differently and still carry the same claim, and the gate is meant to catch that case. It also lets through updates: if a proposal genuinely supersedes an older memory, it is stored with a link to what it replaces, so the history is kept.

Claims instead of blobs

The second decision follows from the first. To judge whether a proposal is new, the memory has to understand what it asserts. So stored content is broken down into typed claims: subject, predicate, object, with a confidence attached. The original text stays, but the claims are what the engine reasons about.

Once you have claims, contradictions become detectable. When a new memory conflicts with an old one, Cortex does not overwrite the old one and does not silently keep both. It records a conflict, with an open state, and surfaces it. You can resolve it, or leave it open as an honest record that two sources disagree. On my instance right now there are twelve open conflicts, and they are exactly the places where the record disagrees with itself, which is what I want to be able to see.

Claims also make citations cheap. Every recall returns the identifiers of the memories it used, so an answer can be audited back to its sources.

Consolidation

Episodic memories pile up even after filtering. A nightly job merges similar episodes into more general memories, tagged as consolidations so the client knows it is reading a summary and not a primary source. The originals are kept and reachable from the summary.

Why MCP

I did not want a memory tied to one assistant. Cortex exposes everything through the Model Context Protocol, so the same memory is available from ChatGPT, from Claude, and from any agent framework that speaks MCP. In practice this is the feature people notice first: a decision taken in one assistant is known by the other one the next morning.

Honest limits

The engine is closed source and only available hosted; the connector and the documentation are public. There is no self-hosted build today. The quality gate is a judgment call and will not suit note-taking use cases where you want everything kept. And a memory that argues with you takes some getting used to.

If you want to try it, there is a 30-day trial without a card at skynetlab-cortex.com. The comparison with Mem0, Zep, Letta and the built-in memories is on the site, written so it can be checked. I'm a solo developer in Italy, so feedback goes straight to the person who wrote the code.

Why is everyone so skeptical of AI memory tools? Fair question. Here are real answers.

Filippo Pilotta — Sat, 22 Aug 2026 15:17:33 +0000

Last week I presented Cortex — a semantic memory for AI assistants I've been building for two years — on Reddit. The response was brutal: "Obsidian works fine." "A text file is enough." "Thanks for inventing RAG for the millionth time."

Instead of deleting the post, I answered everyone. And I realized the skepticism isn't stupidity — it's precious information. This article is the structured version of those answers, including the uncomfortable ones.

(Transparency note: I build memory tools for AIs, and I use AIs daily to multiply what one person working alone can do — including help writing this article. The architecture, the patent filing, the benchmarks and two years of late nights are mine.)

Why the distrust is justified

Three reasons, all well founded.

Saturation. A new "memory tool" ships every week. Almost all do the same thing: save conversations into a vector database, fish them back out. Distrust is an immune response, and it works.

The promises. "Infinite memory," "your second brain," "never forgets anything." Slogans nobody can measure, so nobody believes them anymore.

The black boxes. You hand your data to a system that won't tell you what it saves, why, or what it will answer tomorrow. An AI that doesn't remember is a tool. An AI that remembers badly — picking at random between contradictory memories — is worse than useless.

Cortex was born from exactly these three problems. Not "how do I save everything?" but: how do I decide what deserves to be remembered? And what happens when memories contradict each other?

"Why not Obsidian?"

Because they solve two different problems that look like the same problem.

Obsidian is memory for you, maintained by you: you write, organize, link. It's excellent at that. Cortex is memory for the AI, maintained by the system. Four concrete differences:

Who decides what gets in. In a vault, everything you write gets stored. In Cortex, every write passes a quality gate that in production rejects ~80% of proposals as redundant. A vault has no concept of "this note doesn't deserve to exist."
Contradictions. In a vault, the March note and today's note coexist in silence. Cortex detects and tracks them.
Where it works. A vault lives on your desktop. Cortex is identical from the web, your phone, Claude and ChatGPT.
Maintenance. A useful vault is a garden that needs pruning. Cortex prunes itself.

The honest concession, same one I made on Reddit: if you're disciplined, desktop-only and single-model, a good vault covers most of the need. For free. Obsidian archives documents. Cortex governs memories.

"A memory.md file is enough"

At first, it is — we've all been there. Then it grows: no deduplication, no contradiction detection, and it gets pasted whole into every conversation's context — and context costs money. A memory file is a sticky note: perfect as long as the project fits on a sticky note.

"What about Mem0, Zep, Graphiti?"

That's the right comparison class, and they're solid projects. If you can self-host and want full control, use them. The differences I claim: Cortex is hosted with zero setup (works from your phone, no infrastructure), the write-time quality gate is the core of the design rather than an option, and conflicts are first-class objects.

"It's just RAG with marketing"

The retrieval side is RAG, no argument: embeddings, semantic search, context handed to the model. But classic RAG is a read-only pipeline over an archive someone else has to keep clean: it indexes everything, and answer quality depends entirely on archive quality.

Cortex steps in where RAG stops:

Writing is governed — novelty filter, facts extracted as typed claims, deduplication at write time.
Memory has a lifecycle — consolidation over time, updates linked to the record they supersede, a database that refines itself instead of bloating.
An epistemic layer — tracked contradictions, a coherence score, citable sources.

RAG retrieves from an archive. Cortex curates the archive. If that's still "just RAG" to you, fine: it's RAG with a bouncer.

The best question Reddit asked: "When two memories contradict each other, who decides which one wins?"

The system doesn't choose in silence — that's a design decision. Search returns both memories, flagged with a warning, reliability scores and dates. The synthesis layer prefers the most recent but declares that the older one has been superseded, citing both. And the conflict remains an object with a status: open or resolved. You can list them; you can resolve them yourself.

One rule: the system may have an opinion about who wins, but it never has the right to hide the disagreement.

The uncomfortable number

On the LoCoMo benchmark (1,986 questions over long conversations), Cortex scores ~69% with the filter off and ~56% with the filter on. We published both numbers ourselves.

Why publish the worse one? Because the filter isn't free: 13 points is the measured price of a memory that rejects 80% of writes instead of accumulating everything. LoCoMo rewards total recall of conversational trivia; a memory that filters trivia loses points on trivia questions, by design. Meanwhile adversarial questions stay at 95%, and storage drops by 30%.

Filter off tells you the retrieval engine is at state-of-the-art level. Filter on is a different objective: governed memory, not maximum recall. Choose what you need — but choose it with the numbers in front of you, not the slogans.

The quick ones

Open source? No — the engine is closed, covered by a patent application filed May 2026. The connector, docs and examples are on GitHub, and Cortex is on the official MCP registry. I'd rather say it to your face than dance around it.

Do I need an account to try it? No: add the remote MCP connector to your client and the trial space creates itself on first sign-in. 30 days, no credit card.

Why pay when open source is free? If you can self-host, genuinely, do it. Cortex is for those who can't or don't want to.

Who's behind it? One person: independent researcher, founder of SKYNETLAB, Bergamo, Italy. Two years of work, no team, no funding.

What I actually learned from getting roasted

Skepticism toward AI memory tools is rational — the category earned it. The only sane response is verifiability: publish the write path, publish all the numbers (including the ones that hurt), and keep disagreements visible instead of swallowing them.

Every answer here is written down, with the numbers, on the FAQ page. Brutal feedback welcome — it's the most useful gift you can give. I learned that this very week.

DEV Community: Filippo Pilotta