One interface. Eight memory subsystems.
Procedural · Knowledge · Working · Episodic · Entity · Prospective · Reflective · Spatial
XSI-AIMS Atlas is the memory routing engine for the XSI-AIMS™ memory family. Agents call one interface; Atlas routes each call to the right subsystem and the right backend.
Memory shouldn't be a hard wire.
XSI-AIMS recognizes seven core memory subsystems plus an optional spatial profile. Each has different reliability, recall, and consistency needs. Agents should declare what kind of memory they need, not which database holds it. XSI-AIMS Atlas is the engine that makes that possible.
Eight subsystems. Pluggable backends.
Procedural memory subsystem.
How the agent does what it does — skills, procedures, the workflow corpus.
Knowledge retrieval subsystem.
What the agent knows about — semantic knowledge, the retrieval surface.
Working memory subsystem.
What is in flight right now — per-invocation scratch, by design never indexed across sessions.
Episodic memory subsystem.
What happened — a raw event tier and a consolidated tier.
Entity memory subsystem.
Entity facts over time — bi-temporal, queryable as-of any date.
Prospective memory subsystem.
Future-directed intentions — triggers, reminders, commitments. Added by RFC-0021.
Reflective memory subsystem.
Lessons learned — promoted into procedure through a governed gate. Added by RFC-0021.
Spatial memory subsystem.
Locality, paths, regions — an optional profile for embodied and mapped domains.
Bring your own.
Each subsystem has a default backend and supports drop-in alternatives at registration time.
Spanning all of them — the Trust and Memory Provenance bus (TMS): promotion, consolidation, and provenance through one governed contract. The bus is not swappable. That is the point.
Agents call the single Atlas interface — write, search, read. Atlas connects to eight memory subsystems: PMS, the procedural memory subsystem, how the agent does what it does; KRS, the knowledge retrieval subsystem, what the agent knows about; the working memory subsystem, what is in flight right now — per-invocation scratch, not indexed across sessions; the episodic memory subsystem, what happened, in a raw tier and a consolidated tier; the entity memory subsystem, entity facts over time, queryable as-of any date; the prospective memory subsystem, future-directed intentions; the reflective memory subsystem, lessons learned, promoted into procedure through a governed gate; and the spatial memory subsystem, locality, paths, and regions, an optional profile. Beneath each subsystem sits a swappable backend slot — each subsystem has a default backend and accepts drop-in alternatives at registration time. Spanning all eight runs the TMS trust and provenance bus — promotion, consolidation, and provenance through one governed contract. The bus is not swappable.
One vector store can't do eight jobs.
At prototype scale, memory never gets asked the hard question — one vector store and a generous context window carry a single demo agent fine. At fleet scale it dominates. A fleet puts tens or hundreds of agents in production, each making thousands of calls a day, and every call embeds a memory decision — what to read before acting, what to write after, where both should live. Multiply a per-call decision by fleet volume and memory becomes the highest-variance component in the stack.
The default architecture handles none of it, because the default architecture is one store — one vector database, one similarity-ranked access pattern, every kind of memory forced through it. That pattern is right for exactly one job — finding a relevant fact among many — and wrong for everything else agents remember. Reliability, recall, consistency, and cost diverge subsystem by subsystem. A skill retrieved at cosine similarity 0.71 is not a skill the operator can rely on. An audit record that can be overwritten is not an audit record. And the bill is unforgiving — memory mis-stored is paid for on every call, then ages in place with no consolidation path. Atlas routes each operation to a subsystem-appropriate store so the contract is declared, not improvised.
Stop paying for context you don't read.
When there is one store and one context window, the path of least resistance is to carry everything — accumulated history, retrieved documents, prior tool results — stuffed into every call. Context-stuffing is not a design decision anyone defends. It is what emerges when memory has nowhere better to live, and it bills by the token. Type-aware routing returns targeted store reads instead — the working set in flight, the few facts that match, what is true of the customer as of today. The prompt carries what the call needs, not what the fleet has accumulated.
The ratio — 8× fewer input tokens — is set by the token counts alone, so it holds at any price. The dollar delta scales with the model's published rate, and on a million-call-a-month fleet it lands in five to six figures monthly at current list prices. Prompt caching narrows the raw arithmetic — published cached-read discounts mean the uncached numbers are a bound, not a floor — and agent working sets are rarely byte-stable, so the carried context is precisely the part that keeps invalidating the cache. The whitepaper works the full economics.
The research is converging.
In the MemGraphRAG team's KDD 2026 evaluation (arXiv:2606.00610), three published graph-RAG retrievers ran the same multi-hop benchmarks and landed roughly 180× apart on retrieval latency — 0.061 seconds per query at one end, 11.052 seconds at the other, HippoRAG between them at 1.586. That spread is the memory-complexity problem in one number — the variance between implementations is the cost of the missing contract, and the knowledge subsystem is where the field's energy already sits.
The convergence is sharper still. H-Mem (CUHK-Shenzhen and Huawei Cloud, arXiv:2605.15701) and MUSE-Autoskill (ByteDance, arXiv:2605.27366) each split working memory from episodic memory — independently, neither citing XSI-AIMS, in papers submitted within eleven days of each other. XSI-AIMS formalized that boundary as normative in the same weeks (RFC-0021, Accepted June 3, 2026). Two independent teams arriving at the same line is convergence, not influence — and it is claimed here as exactly that. The under-built layer was never another store. It is the routing and governance contract above the stores.
What memory routing does not solve.
Naming the limits is part of the contract. Routing cannot repair a bad write — Atlas delivers the read to the right store and the write to the right contract, but it does not validate that what the agent wrote was true. Memory poisoning, stale facts written confidently, and duplicated insights are write-side quality problems, and they pass through a correct router untouched.
Routing does not fix prompts, either — an agent with a broken system prompt and perfect memory routing is a well-informed agent doing the wrong thing. Policy tuning is engineering, not configuration theater — choosing consolidation, decay, and retention windows for a given workload is real work XSI-AIMS deliberately leaves to the operator. And XSI has published no Atlas benchmarks. Every number on this page is a cited external result or the labeled illustrative arithmetic above — when Atlas performance figures exist, they will be published as such.
Read the whitepaper.
The full token economics, the consolidation and decay policies as declarable objects, and the eight-subsystem analysis behind this page are in the whitepaper — Memory Routing at Orchestration Scale. XSI-AIMS is an open standard — XSI-AIMS Atlas is the commercial engine that runs it.
Commercial. Contact-gated.
XSI-AIMS Atlas is licensed by XSI — reach out and we onboard your team directly.
Route a call across two stores.
// Register your backends once. Atlas is backend-agnostic — pgvector + Redis are shown as one example; bring your own.
const atlas = new Atlas({
KRS: new PgVectorBackend(process.env.PG_VECTOR_URL),
Working: new RedisBackend(process.env.REDIS_URL),
});
// Then route by subsystem. Atlas handles the right backend.
await atlas.write('Working', { sessionId, message });
const facts = await atlas.search('KRS', query, { limit: 8 });Determinism is the reliability primitive — not a nicety. Strip the memory model to one property and it is this: the same query, from the same agent, under the same declaration, routes to the same stores — every time. The argument is a short chain, and each link is where fleets break. Nondeterministic retrieval makes agents unreproducible — a similarity search whose results shift with index state or embedding drift is the one unversioned input, while the model is pinned and the prompts live in source control. Unreproducible agents make incidents un-debuggable — when an agent misbehaves, the first question is what did it know when it acted, and without deterministic routing, replay degrades to re-run-and-hope. The property holds because routing and promotion cross one governed bus — TMS, non-swappable by design — rather than eight private contracts. One surface where same-declaration-same-stores either holds or detectably does not. That is the spine.
Three runs cross the routing lane. Run 1 carries the declaration “query Q, knowledge plus working” and routes to two subsystems: KRS and Working. Run 2 carries the identical declaration and routes to the identical two subsystems, KRS and Working. Run 3 carries a different declaration, “what happened last sprint?”, and routes to the Episodic subsystem instead. Same declaration, same subsystems — reproducible agents.
Full walkthrough provided at onboarding.
Conformance by declaration.
At registration time, XSI-AIMS Atlas declares which XSI-AIMS memory subsystems it serves and which backends are wired. The XSI-AIMS agent registry records the declaration and exposes it for conformance audit. Memory writes and reads are not exposed; the declaration of capability is.
Commercial, conformant.
XSI-AIMS Atlas is a commercial XSI product implementing the open XSI-AIMS standard — XSI-AIMS defines the governance contract; Atlas is one of the ways XSI runs it. Its conformance declaration lives in the public XSI-AIMS agent registry.