Updates

Every fact kept, every claim checked, forgetting per fact

Fixes from our first beta tester's report and an independent review that followed it. Each fix has a regression test.

• Long messages lose no facts. Messages are now read in full up to the 20,000-character limit. Before, facts after roughly the first 850 characters of a long message could be missed. Filler in long messages is still left out.
• Outside claims are always checked. When a web page, email or tool result says something about the user, Mercury compares it with what the user has said. A clash becomes a dispute and a question for the user; an outside source can never quietly replace the user's word.
• Forgetting works per fact. "Forget where I live" removes that fact, its part of the original message and anything derived from it, and keeps the other facts that message contained. Recall logs that showed it are cleared too.
• Policies cut only what they block. A never_store rule removes the matching sentence from the stored message instead of hiding the whole message, and each sentence is checked on its own.
• Confirmed claims become the user's word. Once the user confirms an outside claim, it is shown with their own statements, marked as confirmed.
• Safer writes. A message and everything derived from it are stored in one transaction, so a failed write stores nothing and a retry works.
• Edge cases. Forgetting a newer fact no longer brings back the one it replaced, expired facts are not disputed, and a sentence split across two parts of a long message stays joined.

Benchmark: 0.962 on the held-out split, the same as 1.3, so the fixes cost no accuracy.

MCP server, website and invite-only beta

• MCP server. Mercury works in Claude Code, Claude Desktop, Cursor and any MCP client, as a remote server at /mcp or a local one, with 14 memory tools.
• Self-serve accounts. Sign up with an invite code, create and revoke API keys, and see Memory Token usage and memory spaces on the dashboard.
• Docs and agent skill. Setup for every client, the full API reference and skill.md, which teaches an agent when to recall, remember and forget.
• Fair use. Per-account rate limits and a cap on requests in flight, so one busy account cannot slow down the rest.

Hosted API and Python SDK

• Hosted memory. Mercury runs on our servers, with a separate memory space per user, agent or project.
• Local mode. Mercury runs in your own process and your memory stays on your machine; only the judgment work goes through the API.
• Memory Tokens. One meter for both modes, priced by the work done rather than the number of calls. Forgetting and reading your memory's history are free.
• Safe retries. Every message has an id, so a retried write is never stored or charged twice.

Keep what people say about themselves

• Plain statements from users about themselves and the people in their lives, such as "I'm working on the search revamp", are now kept unless they are clearly small talk. Before, some were judged not worth remembering and were dropped, which caused most of the misses where the answer never reached memory.

Benchmark: 0.962 on the held-out split (95% CI 0.949–0.971), against 0.946 for our previous memory system (p = 0.013). The biggest gain was on "when did it happen" questions (+0.11).

Beyond recall

• Revision with reasons. A replaced fact is recorded as an update (true until then) or a correction (never true). Mercury keeps when a fact was true separate from when it learned about the change.
• Disputes. When an outside source contradicts the user, nothing is replaced: both are shown, labelled, and the user is asked.
• Forensics. why shows what a recall returned and why, replay shows what memory would have said at a past moment, and history shows every version of a fact.
• Policies as code. Rules per memory space, such as "never store health details from email" or "forget locations after 7 days", in plain language.
• Ask instead of guess. When Mercury is unsure about an update, a conflict or what to forget, it raises a question for the user instead of acting.
• Consolidation. An idle-time pass that turns finished tasks into lessons, applies retention, finds conflicts that slipped through and tags lasting preferences.
• Counting. "How many" and "which" questions get a numbered, dated list of the matching current facts.

A review of the first draft found 13 bugs, mostly ways forgotten content could survive in logs, notes or nearby conversation. All were fixed before release, each with a test.

Cleaner memory, dated answers

• Assistant replies are judged like everything else, so filler such as "Here's a draft you can adapt" is no longer stored and offered back as memory.
• Unrelated facts no longer replace each other: "I commute by bike" does not end "I drive a Tesla".
• Current facts say since when they have been true, so "when did I start?" can be answered from memory.
• Weak matches are shown apart, as loosely related, so the model does not mistake them for answers.

Benchmark: 0.946 on the development split, up from 0.934.

First version

Mercury replaced our earlier memory system, which needed retuning for every new benchmark, with one design and one frozen configuration.

• A verbatim journal. Every message, email, web page and tool result is kept as it was, and facts are derived from it with their source attached.
• Trust and quarantine. A web page can never override the user, and content that tries to instruct the memory is quarantined: kept for audit, never recalled.
• Forgetting that cascades. Forgetting a message removes everything derived from it and scrubs it from the audit log. Users can ask in their own words.
• A labelled memory sheet. Every recalled item says whether it is current or replaced, the user's word or an outside source's, and about the user or someone else.
• Task memory. Agents start and end tasks, and Mercury keeps what worked as verbatim lessons linked to their source.

Benchmark: 0.934 on the development split, with no forgotten facts left in storage.