Skip to main content
HyphaeDB is agent-native memory infrastructure — a database, written in Rust, built for teams of AI agents that share what they learn. Agents connect as thin clients, store memories, and recall them by meaning. What makes HyphaeDB different is what happens to a memory after you store it.

​
The thesis in two minutes

Most databases are pull-based: knowledge sits still until a query asks for it. The agent that needs a fact has to know the fact exists, and know to ask. In a multi-agent system that is the wrong default — the agent who would benefit from a lesson is usually not the agent who learned it. HyphaeDB inverts that. When you store a memory, the server turns it into a memory diff and releases it into a topology — a gossip protocol running over an HNSW graph. The diff then propagates, hop by hop, to the agent nodes it is relevant to. You do not have to know who needs a fact for it to reach them; the mesh routes it for you. Propagation is bounded so it terminates instead of flooding. Each diff carries an energy budget: every hop costs energy, the cost depends on how strong the edge is, and when a diff can no longer afford to cross any remaining edge it stops. More salient knowledge — a decision, a constraint, a contradiction — is seeded with more energy and travels farther than a routine update. The result is knowledge that finds its audience:
  • Store, don’t broadcast. You write a memory once. The mesh decides where it should flow.
  • Recall by meaning. A vector search over the same HNSW graph that carries gossip returns the memories closest to your query.
  • Watch your inbox. Each agent has a live inbox; diffs that propagate to your node arrive there, de-duplicated and replayable after a reconnect.
A few invariants make this trustworthy. A diff’s origin is immutable, so you can always tell where a piece of knowledge came from. Identity is taken from your authenticated credential, never from the request body, so an agent can never claim to be another. And widely-delivered knowledge can be promoted up a layer hierarchy from working memory toward shared, long-lived memory.

​
How you connect

HyphaeDB speaks four protocol surfaces over one application core, so you pick the surface that fits your client:
  • gRPC — the primary surface: eleven unary RPCs plus a bidirectional inbox stream. See the gRPC overview.
  • MCP — the Model Context Protocol surface for agents, exposed over stdio for Claude Code and other MCP hosts. See the MCP tools overview.
  • REST — an HTTP fallback for clients without a gRPC stack. See the API reference.
  • A2A — opt-in: agents on Agent2Agent platforms reach the same memory through the standard A2A protocol. See the A2A overview.
For most use cases you do not call these directly. Use a client SDK: Python and TypeScript and Rust ship today, with Go planned. Each SDK is a thin smart client — it keeps a warm local read cache and a live inbox, and holds no mesh logic of its own.

​
Where to go next

Quickstart

Bring up the server with Docker Compose, obtain a credential, then store and recall your first memory in under five minutes.

Propagation in five minutes

The thesis, running: watch a memory travel from one agent to another with no query in between.

Core concepts

How gossip propagation, the energy model, and the HNSW mesh fit together.

Client SDKs

Install a language SDK and call the high-level store / recall / inbox API.

MCP tools

The Model Context Protocol tools that let an agent use HyphaeDB as memory.

API reference

The REST surface and its conventions, plus the generated endpoint reference.

Operations

Run, configure, secure, and operate a production deployment.