Most memory bolts a search box onto a pile of old text. Korium runs like a mind instead: it takes things in fast, makes sense of them quietly in the background, and brings back an answer that already understands the connections. This is the walkthrough, in plain language, with an honest look at the technology underneath.
The trick is not storing more. It is separating the fast job of never losing a thought from the slow job of understanding it, so neither one gets in the other’s way.
When an agent records a thought, the write lands instantly and the agent moves on. Nothing waits on a model. The real thinking happens later, in the background, between bursts of activity. That is where Korium pulls apart entities, links them, and resolves contradictions. Recall then reads from the durable graph that quiet work built.
The fast lane keeps raw notes. During the sleep cycle, the quiet lane consolidates them into cognitive memory, typed, linked, and time-stamped, exactly where a raw capture becomes something an agent can reason over.
Korium can index a codebase and answer "where is the code that does this" with exact locations. The difference is the boundary. Your source never leaves your machine. Korium holds only compact cards: a symbol’s name, kind, and line span, plus the vectors to search them. It hands back precise locations. The agent reads only the lines it needs.
Your source stays on your machine. Korium indexes locations, not code, then finds the right spans and returns them as one ranked answer.
Each move has one job and does it well. Together they are the loop a memory runs: take it in, make sense of it, bring it back when it counts.
The write that never waits
An agent records a thought with one simple call. It lands in durable storage immediately and is acknowledged, with no model sitting in the path to slow anything down. The agent declares whatever it already knows about the entities and relationships involved, then carries on with its work.
Because the write is durable the instant it arrives, even an abrupt crash mid-stream cannot tear or corrupt the record. What an agent commits to memory stays committed. The expensive interpretation is deliberately deferred, which is exactly what keeps this step fast.
The work between the work
When activity settles, Korium does the thinking it put off. It fills in the entities and relations an agent did not spell out, links each new capture to everything already known, and weighs every fresh claim against the existing record.
Contradictions surface here instead of piling up. A belief that has been replaced is marked as superseded rather than erased, and every fact is stamped in time so the graph can always answer what was true, and when. This is the step that turns a stream of raw notes into a memory that actually holds together.
Three lenses, one answer
A query runs through three lenses at once: exact keyword match, meaning, and the graph of relationships around the idea. Related facts pull in the context that surrounds them, so the agent sees the whole neighborhood of a question, not one isolated hit.
The results come back as a constructed recall about the thing asked for, scoped to the project, app, or context in play. The agent reads a coherent account it can act on, instead of sifting a list of fragments and guessing at the thread between them.
Keyword search is precise but literal. Semantic search understands meaning but drifts. The graph knows how things connect but not what you typed. Korium runs all three, then does the hard part: fusing them into a single, scoped, readable recall.
Anyone can run three searches. The value is in the fusion and ranking that turn three noisy signals into one trustworthy answer, and that logic is ours.
Most stores keep only the latest value. When a fact changes, the old one is overwritten and the history is gone. Korium keeps the whole timeline. A replaced belief is stamped with the moment it stopped being true. The new belief records that it supersedes the old one. So you can always ask the graph what it knew on any past date.
Ask a question as of a past date and you get the answer as it stood then. Later corrections live as their own thread, never overwriting the record.
We are not shy about the foundations. They are deliberately boring, battle-tested, and the right call. The value Korium adds lives in the layer above them, in how the pieces are orchestrated. That layer is the one we keep private, and the table below draws the line honestly.
| Layer | The proven foundation we build on | What we keep proprietary |
|---|---|---|
Interface |
Model Context Protocol and REST. Open, documented protocols any agent or client can speak, with no lock-in at the wire. | The tool surface and the vocabulary contract that lets an app teach Korium its own domain without a rebuild. |
Runtime |
Elixir on the BEAM. Lightweight concurrency and supervision trees give crash-safety and the ability to run thousands of small jobs at once. | How we schedule the two speeds so writes stay instant while heavy consolidation runs quietly in the background. |
Storage |
PostgreSQL with write-ahead logging. Durable, crash-safe, and boringly reliable, so a committed memory is never at risk. | The schema and lifecycle that let raw captures consolidate into a clean graph instead of an ever-growing pile. |
Retrieval |
Hybrid search over three signals: lexical keyword ranking, vector similarity for meaning, and graph expansion around a hit. | The fusion and ranking that turn three signals into one answer, and the composition that returns a narrative, not a list. |
Memory graph |
Typed entities and relations with bitemporal validity. The idea of a graph and a valid-time axis is well understood in the field. | The universal type core every app extends, and exactly how consolidation populates and prunes it as beliefs change. |
Consolidation |
Asynchronous background workers. A standard pattern for doing expensive work off the request path. | What to extract, how to link, and how to resolve conflicts. This is the heart of Korium, and the part we guard most closely. |
Isolation |
PostgreSQL FORCE row-level security. Tenant separation enforced by the database itself, not just by a filter in application code. | The tenant model that lets one identical build serve a single laptop user or thousands of teams safely. |
Fairness at scale |
Admission control and per-tenant queue fairness. Common ideas for keeping one heavy user from starving the rest. | The limits and back-pressure ladders tuned for onboarding whole fleets at once without a noisy neighbor problem. |
Self-improving loop |
Outcome measurement with gated changes. Measure a result, keep a change only if a hard number says it helped. | The evaluators and the guardrails: what we measure, and precisely what we let the loop change on its own. |
Why show any of this? Because the foundations are not the moat, and pretending otherwise fools no one. Elixir, PostgreSQL and hybrid search are excellent, public building blocks. Korium is the judgment layered on top: how the two speeds are scheduled, how three retrieval signals are fused, and above all what consolidation chooses to extract, link and reconcile. That orchestration is what we keep private, and it is what you are actually paying for.
The system watches how its own work lands, judged from the outside on what actually happened, not on its own opinion of itself. A change survives only when a hard, repeatable measure shows it beat what came before. Humans stay on the decisions that matter: the architecture, the security, and the measures themselves.
Point an agent at it and see the loop run: fast capture, quiet consolidation, and recall that already knows the connections. Explore the plans, or talk to us about what you are building.
See Korium plans
