You explain your project to Claude Code. You switch to Cursor and explain it again. You open Codex and explain it a third time. Nobody benchmarks this tax, but everyone pays it.
Atlaso is a memory layer that promises to end it: connect once, and Claude Code, Cursor, Codex, Claude Desktop, OpenCode, and Antigravity all read from and write to the same store. It hit #4 on Product Hunt's August 4, 2026 daily leaderboard with 248 points, and it arrives with something most launches skip — a published benchmark study that includes the benchmark Atlaso loses.
That honesty is the most interesting thing about this product. It's also, unfortunately, what makes the gap between the research and the shipped tool so visible.
Setup: one command, one minute
Installation is a single line, identical across macOS, Linux, and Windows:
curl -fsSL https://atlaso.ai/install.sh | bash
It opens a browser, you authorize the device, and Atlaso installs itself into whichever tools you pick. For Claude Code that means three components — hooks, an MCP server, and a skill. Tools without a terminal get a connector URL instead. There are no config files and no API keys to wrangle, which is genuinely rare in this category.
Anything that speaks MCP can connect. ChatGPT and Meta AI are listed as soon.
How the memory actually works
Two things happen automatically once a tool is connected: capture after each turn, recall before the next one.
Capture pulls durable facts out of your session — decisions, watch-outs, open questions — and drops the chatter. Secrets are scrubbed client-side before anything is sent: API keys, tokens, private keys, passwords, credentials in URLs. Sync runs in the background and never blocks your turn.
Recall runs keyword and semantic search, ranks the results, and injects the winners into context before the model sees your prompt. The mechanics are published rather than hand-waved:
| Parameter | Value |
|---|---|
| Memories injected per turn | Top 5 |
| Relevance floor | 0.5 — below it, not injected |
| Freshness half-life | 14 days |
| Supersede threshold | 0.5 |
The injected block is plain text wrapped in === ATLASO MEMORY === markers, so nothing is hidden from the model. Whether you can see it is another matter — more on that below.
Memory is scoped two ways: personal, which follows you everywhere, and per-project, locked to a repo. Every recall also carries a verdict — settled, contested, or thin — so the model knows whether it's acting on consensus or a single stray note.
The benchmark study is unusually good
Most memory vendors publish self-graded numbers. Atlaso published a four-judge head-to-head in May 2026 that holds the fixture, the reader, and the judges fixed across arms.
The setup: LongMemEval-S, n = 500, a shared Qwen 3.5-9B reader, and four independent judges — Haiku 4.5 strict, GPT-5 permissive, GPT-4o strict, and mem0's own verbatim judge prompt. Answers are normalized to strip system fingerprints so judges can't tell which arm wrote what.
| Judge | Atlaso | mem0 | Δ |
|---|---|---|---|
| Haiku 4.5 strict | 61.8% | 47.0% | +14.8pp |
| mem0 verbatim | 56.4% | 44.2% | +12.2pp |
| GPT-5 permissive | 57.8% | 46.4% | +11.4pp |
| GPT-4o strict | 69.2% | 59.4% | +9.8pp |
No judge flips the direction. Two findings from the same study are more valuable than the win itself.
First: mem0's widely cited 93.4% on LongMemEval-S does not reproduce. Running mem0's default OSS pipeline on the same fixture and scoring with mem0's own judge prompt, Atlaso measured 44.2% — a 49.2-point gap. Atlaso is careful here, noting they did not reproduce mem0's full managed-platform configuration, so the gap should be read as "methodology plus pipeline."
Second: retrieval recall is not QA accuracy. In a 2×2 retriever-reader swap, MemPalace won top-5 retrieval recall by 31 points (96.2% vs 64.9%) and still lost end-to-end QA (58.6% vs 61.8%). On preference questions — where the answer is one sentence buried in a long session — session-level retrieval collapsed from 56.7% to 16.7%.
And the loss they published anyway:
On the adversarial LoCoMo subset (n = 200), Atlaso scored 24.0% against mem0's 35.5% — a 11.5-point loss. The stated cause: the system over-abstains or returns planted distractors with high confidence on temporal-reasoning traps.
Cost came in at $0.0096 per query versus mem0's $0.0115 (1.20× cheaper), with zero LLM calls at ingestion against mem0's one gpt-4o-mini call per turn — though the mem0 extractor cost is modeled, not traced.
One irritation: the landing page advertises a different set of numbers — 92% evidence recall, 67% QA accuracy, 95% Hit@k — from an n = 100 run through the shipped product path. Two benchmark presentations at two sample sizes on the same fixture is confusing, and the marketing figures are the ones most people will see.
Where the shipped product falls short
To the founder's credit, most of what follows comes from his own answers in the launch thread rather than from testing that contradicted him.
Supersede doesn't fire on its own. The machinery to retire an outdated memory exists, but nothing in the shipped tools triggers it. A decision you reversed three sessions ago stays live, and it reads exactly as confident as a correct one. You can tell the AI something changed and the MCP will handle it — but only if you remember to.
You can't see what got injected. In Claude Code and Codex the recalled block goes to the model, not your terminal. Killing a bad memory means a trip to the web dashboard, not a keystroke.
Nothing ever expires. There is no decay and no pruning; the store only grows. The injected context stays constant at five memories whether you have 50 or 5,000, so this affects your archive rather than your prompt — but there's no garbage collection.
No team memory. Atlaso is partitioned per user. No shared layer, no roles, no attribution. The founder's suggested workaround for teams — one paid account shared across devices — comes with his own warnings about rate limits and the fact that anyone can delete anything.
No self-hosting. Nothing today, and the founder says plainly it isn't ready for a locked-down repo.
Only two scope levels. Personal or one repo, with nothing in between. Related repos can't share a space without going fully global, and a package inside a monorepo with its own package.json gets treated as a separate project.
One discrepancy worth flagging: the pricing page says Pro includes unlimited devices, while the founder told a commenter that a paid account allows up to 100 devices. Not a dealbreaker, but check it before planning around it.
Pricing
| Plan | Price | What you get |
|---|---|---|
| Free | $0 | 1 device, 1 active tool, unlimited memories, cloud sync, dashboard, secrets scrubbing |
| Pro | $10/mo | Unlimited devices and tools, Ambient Memory, nightly background enrichment, Ask your memory, JSON export |
| Build | $25/mo | Everything in Pro plus a memory API, per-end-user isolated memory, project API keys, usage dashboard |
Monthly only — no annual plan, no trial, because the free tier is the trial. Memories survive a downgrade, extra devices get a five-day grace window, and EU/UK customers keep a 14-day refund right.
Here's the catch: the free plan allows one tool. The entire premise of Atlaso is memory that crosses tools. On Free, it doesn't cross anything. So $10 a month is the real price of the product as advertised — the free tier is a demo of a feature that isn't the point.
On privacy, the free plan has an interesting property: your memory is never sent to any LLM at all. Data is encrypted in transit and at rest, access tokens are stored as hashes, and Atlaso states it never trains on or sells memory.
The Bottom Line
Atlaso is the most intellectually honest product I've reviewed this year. Publishing an 11.5-point loss, a failed reproduction of a competitor's headline number, and an admission that their own preregistration is a version trail rather than a clean prior commit — that's not how launches usually go, and it earns real trust.
The shipped tool hasn't caught up to the research. Superseding is the whole reason a memory layer beats a notes file, and it currently requires you to notice the stale memory yourself — which is precisely what you installed this to avoid. Until you can see an injected memory and kill it from the terminal, the failure mode is an AI that confidently reminds you of a decision you already reversed.
Try it on one repo where being wrong is cheap. If the recall lands more often than it misleads, $10 is a fair price for not re-explaining yourself six times a week. If you need team memory, self-hosting, or a middle scope between personal and one repo, this isn't ready — and the founder will tell you so himself.
