Deterministic Memory Infrastructure

Memory for teams
shipping agents

Replayable retrieval. Proof-carrying search. Scoped memory by session, domain, and case.
Public memory edge for live traffic, private control plane for operations.

Get Started Documentation

+- AGENT TEAM -----------------------+ | [SDK / MCP / API] <-> [Memory Edge] | | | | | (Proof + Replay + Verify) | | v | | +-----------------------+ | | | Snapshot v3 / Restore | | | | Encrypted Memory Node | | | +-----------------------+ | +------------------------------------+

Why this exists

Production agent memory still fails in the same places

State drift, missing proofs, weak portability, and unsafe exposure.

State dies with the runtime

Most agent stacks still treat memory as prompt residue. Restart the process, move regions, or switch infrastructure and continuity falls apart.

"LLMs are stateless. Their weights are frozen and do not update during use. When a session ends, the context clears." — Morph LLM, Feb 2026

Hippocampus solves this → STORE + SNAPSHOT v3 + RESTORE. Memory survives session boundaries, cluster movement, replay drills, and operational failover.

Memory is trapped in products, not infrastructure

Teams can move models and tools faster than they can move memory. That creates lock-in and makes rollout between environments brittle.

"MCP must support not just technical interoperability, but economic interoperability — ensuring memory remains portable rather than becoming proprietary moats." — New America / OTI, Nov 2025

Hippocampus solves this → Portable snapshot bundles, deterministic verification, and open SDK/MCP integration paths for moving agents without rewriting the state layer.

Retrieval cannot be explained

When search order changes silently, incident review turns into guesswork. Teams cannot explain why an agent answered the way it did.

"The cost of non-determinism shows up quietly — in bugs that can't be reproduced, failures that can't be explained, and audits that go sideways." — Kubiya.ai, 2025

Hippocampus solves this → Integer-only ranking plus proof replay. Same query + same memory state = same ordering, same proof factors, and a verifiable result set.

Why teams adopt it

We focus on operational memory, not just prompts

Capability	Typical stacks	Hippocampus
Deterministic retrieval	Best-effort ranking	Stable ordering + proof replay
Scoped retrieval	Prompt conventions	Exact-match filters for session/domain/case
State portability	Ad hoc exports	Snapshot v3 teleportation
Public deployment posture	Mixed app and memory exposure	Public edge, private core
Operator evidence	Opaque logs	`verify/full` + tamper-detecting restore

Built for coding agents, support agents, internal copilots, and regulated agent workflows where memory has to be portable, testable, and auditable.

Platform Counters

USERS

AGENTS

Built for operator-grade memory

Deterministic Retrieval

Integer-only ranking merges lexical overlap and semantic closeness with stable tie-breaks. The same state yields the same ordering, which makes replay, diffing, and incident review practical.

            "algorithm": "AMP-D-Hybrid-v2"

            "hamming_distance": 27

            "lexical_overlap": 8

Scoped Retrieval

Constrain search by session, memory domain, case, source system, segment class, or time horizon without hiding scope logic inside prompts.

Zero-Knowledge Keys

Client-side encryption keys (AES-256 / ChaCha20) managed by the SDK or MCP. Your memory key never leaves your machine — we store only encrypted blobs.

Proof Replay

Search results carry proof factors. `verify/full` replays the result set against current memory state and fails when order or proof factors drift.

Snapshot Teleportation

Snapshot v3 exports deterministic state with segment manifests, catalog, and checkpoint root. Restore moves cleanly across regions and hard-fails on tampered bundles.

How teams use it

Create Workspace

Provision one or more workspaces for your team. Choose grouped mode or shared-memory mode depending on whether your agents should collaborate directly.

Bootstrap Agents & Members

Register each runtime, issue bootstrap credentials, and invite trusted collaborators into the same work group when you need shared memory.

Ship With SDK or MCP

Use MCP or SDK clients to store, scoped-search, snapshot, restore, verify memory, and monitor agent live sync across the workspace map.

OpenClaw Ready

Install Hippocampus Skills From ClawHub

Use Hippocampus with OpenClaw through a bootstrap-first setup, then install the branded skill set from ClawHub.

Connect Your Root Agent

Create a workspace, add an OpenClaw root agent, and run the generated bootstrap command once on the target machine.

Open Dashboard

Get The Skills

Browse and install the Hippocampus skill family in ClawHub for onboarding, memory retrieval, and sub-agent isolation.

clawhub.ai

Browse ClawHub

Who it is for

Agent Product Teams

For teams running customer-facing copilots, coding agents, support workflows, and multi-agent backends that need durable state, not just more context window.

Platform & Infra Owners

For operators who need evidence, rollout discipline, public entrypoint control, and a memory layer that can survive region moves and cluster maintenance.

Public Edge, Private Core

Public nodes expose only the memory edge. Dashboard and heavier support services stay internal behind cluster routing.

Deterministic Operations

Validated on public edge gateways with exact retrieval checks, `verify/full`, snapshot v3 replay, and MCP bootstrap from a real client path.

Run memory like infrastructure

Start with a workspace, connect your agents to the nearest memory edge, and validate replay, portability, and proof verification before you scale traffic.