Why MemoryCrux
AI agents are the most capable tools ever built. They are also the most forgetful. MemoryCrux exists to close that gap.
One memory layer. Every agent.
The agent memory wall
Every organisation that deploys AI agents hits the same wall. The agent can write code, draft contracts, query databases, and orchestrate complex workflows. But it has no idea which database is production. It doesn't know that the vendor you're migrating away from has a 90-day notice clause buried in an email thread from 2024. It has never heard of the unwritten rule that staging deploys need sign-off from the platform team on Fridays.
This knowledge exists. It lives in the heads of senior engineers, in Slack threads that scroll past, in Claude and ChatGPT conversations that expire when the session ends, in meeting notes that nobody indexes. It is the institutional judgment that keeps organisations running. And none of it is available to the agents that are increasingly making decisions on behalf of those organisations.
The result is predictable. 75% of frontier models break previously working features during routine maintenance tasks. Not because they lack capability, but because they lack context. An agent with GPT-4 level intelligence and zero organisational memory is a powerful tool wielded blindfolded.
This isn't a hunch. It's measured.
ScoreCrux is our open benchmark for how well agents carry context — scored out of 100 against published negative controls: an oracle ceiling and a random floor. Two results make the case for memory over brute-force context.
Core recall at 2M-token scale
higher is betterFind 25 decisions + 5 needle facts across 3,346 documents — the Delta corpus, ResearchCrux.
More context makes strong models worse — and costs up to 6.6× more per run for far worse recall.
Context tokens for the same answer
lower is betterNear-identical score; a fraction of the token bill.
~6.7× fewer tokens, and most accurate at resolving which fact was current — ScoreCrux context benchmark, claude-sonnet-5 arm.
More context makes it worse
In ScoreCrux's scale benchmark — 3,346 documents, over 2M tokens, with 25 architectural decisions and 5 needle facts buried in noise — stuffing everything into the window dropped core recall from 44% to 28% on one frontier model and 28% to 8% on another. They drown in their own context. Tool-mediated retrieval held 80–100%, at a fraction of the cost.
Same answer, a fraction of the tokens
In the context benchmark, Crux scored 95/100 while spending ~1,263 context tokens — against a vendor-native memory that scored 97 but burned 8,428 tokens to get there. And when a fact had been changed, Crux was the most accurate at resolving which value to trust. Naive memory surfaces the stale one and fails; only a freshness-aware backend wins — decisively for weaker models.
Figures from ScoreCrux (claude-sonnet-5 arm). Full methodology, negative controls, and per-model runs at scorecrux.com/context and /scale.
It's not just about memory. It's about trust.
When a junior employee joins your company, you don't hand them production credentials on day one. You give them context first. You explain the boundaries, the history, the things that have gone wrong before. Over months, they build judgment. They learn which decisions need approval and which they can make autonomously.
AI agents skip this entirely. Every session starts from zero. Every agent is a new hire with no onboarding, no institutional memory, and no guardrails beyond what the model provider baked into the weights. The organisations deploying these agents have no way to encode their own judgment into the agent's decision-making process.
This is the problem MemoryCrux solves. Not just "give agents memory" in the sense of storing conversations. Real organisational memory: versioned, auditable, with constraints that encode senior judgment as machine-checkable boundaries. Memory that knows when it's stale. Memory that can tell an agent "you don't have enough context to make this decision safely" before it acts.
Built on three layers of infrastructure
MemoryCrux is the surface layer of a three-tier architecture. Each layer solves a distinct problem, and together they create something that no single product offers: organisational memory with cryptographically verifiable records.
CoreCrux
The event-sourced truth layer. Every decision, every state change, every receipt is recorded as an immutable event. CoreCrux provides the append-only ledger that makes the entire system auditable. Powered by Ed25519 signatures and BLAKE3 hashing, it lets an operator detect tampering and verify the order of the events the system recorded.
VaultCrux
The retrieval and proof layer. Semantic search, hybrid retrieval with keyword and vector search, cross-encoder reranking, and receipted provenance for mediated operations. VaultCrux is where knowledge is stored, indexed, and served with confidence scores and provenance receipts.
MemoryCrux
The agent interface layer. 100+ MCP tools that give any AI agent access to organisational memory, decision context, constraints, monitoring, and pre-action verification. MemoryCrux is where CoreCrux's truth and VaultCrux's retrieval become agent-native capabilities via the Model Context Protocol.
This separation matters. Memory without proof is just a database. Proof without retrieval is just a ledger. Retrieval without an agent interface is just a search engine. The three layers together create a system where agents can query organisational knowledge, check proposed actions against encoded boundaries, and bind a recorded decision to the recorded context state that informed it.
What makes this different
Other tools give agents "memory" by storing conversation history or letting you upload documents to a vector database. That solves the retrieval problem. It does not solve the trust problem.
MemoryCrux is built around a different premise: agents need more than information. They need constraints, verification, and receipts. They need to know what they don't know. They need to be able to prove what they knew when they made a decision.
Constraints, not just context
Declare organisational boundaries in natural language. MemoryCrux converts them into machine-checkable rules that agents hit automatically before acting. "Never run destructive commands on production without operator approval" becomes a real boundary, not a suggestion in a system prompt.
Versioned and temporal
Every piece of knowledge is versioned. You can reconstruct exactly what the system knew at any point in time. When an agent makes a decision based on stale context, MemoryCrux flags it. When knowledge is superseded, the old version is preserved in the audit trail with a clear supersession pointer.
Cryptographic receipts on state changes
Every state mutation produces a signed receipt via CoreCrux. Recorded decisions can be linked to a knowledge-state cursor, and recorded constraint checks remain inspectable. The chain proves integrity, signer and ordering for those records; it does not claim the underlying decision was correct.
Agents know what they don't know
Coverage assessment tells an agent which domains have zero or stale knowledge before it acts. Context briefings are ranked by risk-if-missed and compressed to fit token budgets. Escalation preserves full reasoning state when handing off to a human. Agents become self-aware about their own limitations.
How the daemon keeps memory honest
Winning those benchmarks comes down to four things the daemon does that a vector store doesn't: it knows when memory is stale, it carries work across sessions, it structures that work as plans, and it meters every token.
Drift — memory that knows when it's stale
Every fact carries a freshness horizon — volatile (24 hours), medium (35 days), stable (a year). Once a fact ages past its horizon the daemon flags it stale and warns an agent before it acts on out-of-date context. Re-verify a fact and the decay clock resets with a signed receipt; when a newer value supersedes an old one, both stay in the audit trail with a clear pointer.
Sessions — continuity across runs
Every agent run can save a checkpoint — objective, current milestone, decisions, files touched, next action — and the next run resumes from it instead of replaying the whole conversation. Sessions are journal-backed and survive process restarts, so continuity doesn't depend on a chat window staying open.
ExecPlans — work that spans sessions
Longer work is structured as an ExecPlan: a milestone-by-milestone document with a progress checklist and a decision log that records why choices changed mid-flight. Agents pick up at the current milestone across sessions, and token burn is attributed back to the plan that caused it.
Token burn — every token metered
session_token_usage shows used / limit / percent live; retrieval carries a token budget and truncates rather than blow it; and some queries — counts, sums, current-value, time-range — are answered with zero LLM tokens at all. The cost report attributes the spend back to the ExecPlan and the agent that ran it.
And the same stack powers WikiCrux
WikiCrux is an agent-first knowledge corpus built on the very same retrieval and receipts stack — queried over MCP (wiki_search, wiki_deref, wiki_traverse), with every served passage carrying its source page, revision, and a verifiable CROWN receipt. It shows the same evidence model can support public knowledge as well as private memory, without erasing where a passage came from.
Who it's for
MemoryCrux is for anyone deploying AI agents in environments where mistakes have consequences. Engineering teams where a bad migration takes down production. Legal teams where an agent drafting a contract needs to know about the clause your firm added after the last dispute. Operations teams where an agent managing infrastructure needs to know which servers are load-bearing and which are expendable.
If your agents are making decisions that affect real systems, real money, or real people, they need more than a language model and a system prompt. They need the same institutional context that makes your senior employees trustworthy. MemoryCrux is how you give it to them.
See how it works under the hood
Dive deeper into the architecture, the data flow, and the MCP tools that make MemoryCrux work.