Memory that
keeps its
sources.
Your agent comes back knowing what happened, and can show you where each belief came from. HyperMind is a Rust memory engine for AI agents: it powers memory for hosted Gideon, and it is also a product you can run yourself.
Come back to context, not a blank window.
Memory earns its keep only if it survives the process, shows its work, and fits in the window. Those are the three things HyperMind is built to deliver.
A restart stops costing you the context
HyperMind writes the history down as it happens and checkpoints it. Preferences, decisions, and open work survive a process restart instead of being re-read from a stale summary.
Recall that arrives with its sources
A remembered claim keeps the references that produced it. You can move from the answer back to the record behind it, and material that came from an untrusted place stays labeled as untrusted.
Only what is relevant, and only what fits
Activation assembles the relevant context inside a token budget, so a long history becomes an argument rather than a wall of transcript.
Follow-up that outlives the tab
Intentions, predictions, and outcomes are observed and recorded. Work that was promised yesterday is still visible today, and quiet hours keep the interruptions batched.
Write it down, then make it recoverable.
The ledger is the record. Everything else, indexes, summaries, and recall views, is derived from it and can be rebuilt.
An encrypted append-only ledger
Memory is an append-only ledger rather than a blob rewritten in place. Entries are encrypted at rest, so the history can grow without quietly editing what came before it.
Projections you can rebuild by replay
Indexes, summaries, and recall views are projections of the log, not the source of truth. If one is wrong or lost it is rebuilt by replaying the ledger, so recovery never depends on trusting an opaque in-memory snapshot.
Checkpoints and restart continuity
Periodic checkpoints bound how much of the log has to be replayed. A process that stops and starts again resumes from durable state instead of beginning from an empty window.
Remembering a claim does not verify it.
That principle is the design constraint. Activation produces evidence-labeled context, not executable instructions: a recalled claim arrives with what supports it, and untrusted memory keeps its label.
Retrieval you can reason about
Lexical retrieval finds records by what they actually say, which makes a miss debuggable rather than mysterious.
Embeddings when they help
Embedding-based similarity is optional. Semantic recall is an added path, not a replacement for exact evidence.
Beliefs that know when
Beliefs are time-aware. What was true in March and what is true now remain distinguishable, and a change is recorded as a change rather than a silent overwrite.
Disputes are first-class
A claim can be disputed. Disagreement is recorded as disagreement, so the engine never has to pretend the record was unanimous.
References travel with the claim
Recalled context carries its source references with it. The path from conclusion back to origin is part of the answer.
A budget, not a hope
Activation is budgeted. Relevant context is assembled to fit, and untrusted-memory labels survive the trip into the window.
The thread stays visible after you close the tab.
Intentions, predictions, and outcomes
What the agent set out to do, what it expected, and what actually happened are recorded as distinct things. A prediction that missed stays visible as a prediction that missed.
Quiet-hours attention batches
Follow-up work can be gathered into attention batches and held through quiet hours, so a remembered obligation does not become a 3 a.m. notification.
Supported procedures
Procedures the agent has learned to rely on are retained with the evidence that they worked, instead of being rediscovered from scratch every session.
Attach it however your agents are built.
stdio MCP
Point an MCP client at the engine over stdio and let the model read and write memory through the protocol it already speaks.
Unix-socket daemon
Run it as a local daemon on a Unix socket: one machine, one owner, and no network surface you did not ask for.
Authenticated gRPC and REST
Expose the same engine as an authenticated service when memory has to be shared across processes or hosts.
Language SDKs
Call it from your own code instead of hand-rolling the protocol, whether the caller is an agent loop or a batch job.
Where it stands.
Active development: v1.0.0 is not qualified or released. Benchmark targets, local test results, and release qualification are different claims, and we do not present them as the same thing.
What exists
A working engine with a durable ledger, replayable projections, evidence-bearing recall, bounded activation, and the surfaces above. It powers memory for hosted Gideon today.
What does not exist yet
A qualified v1.0.0 release. Until release qualification is complete, treat HyperMind as moving software rather than a finished contract.
HyperMind is the memory behind Gideon. Explore Gideon’s memory to see what it remembers and make it your own.
Back to GideonStart with Gideon and keep useful context for the next conversation. You can inspect and edit supported remembered details.