Nothing is deleted.
Everything explains itself.
Echo Memory is a temporal, self-consolidating memory graph for AI agents — built to keep working after months of accumulated history, not just on day one.
Vector search degrades with history. Structure doesn't.
Most memory tools solve short-term recall with flat vector rows: more history means more candidates, more noise, slower retrieval. Echo Memory is built around the read/write algorithm and data structure that keeps working at long horizons.
Bounded retrieval cost
Facts are edges between entities, not flat rows. Old, rarely-accessed memory consolidates into higher-level summaries over time — never deleted, always traceable — so retrieval stays bounded by what's currently relevant.
Real graph structure
Queries like "how did we end up here?" are answerable because facts are connected, not just individually embedded. Personalized PageRank adds associative retrieval across hops in v1b.
No LLM calls to record
Extraction happens in the calling agent, never on the server. Recording a memory costs nothing to run — the tradeoff is that the agent arrives with entities and facts already extracted.
Memory is a graph, not a list of notes.
Entities are nodes; a fact is an edge between two of them. That's the whole data model — everything below follows from it. These are real captures from echo-memory dashboard --serve, run against a synthetic seed.
Three projects, never told about each other
Six services recorded in separate sessions by four different agents. The picture already separates them, because separation is a property of the edges, not a label anyone applied — and the few nodes sitting between clusters are the concepts more than one service turned out to care about.
Everything it takes part in
idempotency keys is the largest node here, and nobody made it large: seventeen facts from several services resolved onto one entity by name. The panel lists every one, with which agent wrote it and when.
Why memory believes it
This is what a knowledge graph gives you that a code map can't. The panel is not a tooltip: it is who wrote the fact, in which project, when, and how each of its entities resolved. A superseded fact is never deleted — it stops being drawn and stays reachable with its full history. echo-memory why <fact_id> prints the same trail in a terminal.
Move your cursor through it — every drifting point is a fact waiting for its edges.
Click a node. Click a link.
A small illustrative patch bay, shaped like the real dashboard above. Relation types are set by the agent's read of the conversation, not inferred statistically — honest about what's tractable today.
Click a jack to see what it connects to, or a cable to see its full provenance — the same trail
echo-memory why <fact_id> prints in a terminal.One storage engine, every scale.
Postgres, from a single local agent up to an org-wide shared graph. The novel work is the memory structure and read/write algorithm running on top of it — not a new database engine.
PostgreSQL + pgvector + Apache AGE
Vector similarity and graph traversal in the same database. No forced migration later as the graph grows from one agent to an organization.
Hybrid, then multi-hop
Vector + full-text search ships in v1a. Personalized PageRank via networkx lands in v1b for associative, multi-hop retrieval.
Model Context Protocol
Any MCP-compatible agent reads and writes the same graph — a coding assistant, a chatbot, an ops agent, or something built in-house.
write_episodequery_memoryget_audit_logNumbers, and how they were taken.
Every figure comes from the repository or a live store, on a date. The corpus is small and the noise floor is stated, because a difference nobody sized is not a result.
768 cases across three one-hop query shapes and 187 multi-hop ones, each configuration scored against the same cases and compared on a seeded paired bootstrap. It has overruled three of its author's own bets, one already shipped. What it cannot do is measure quality — every query is derived from its own answer, and the harness says so in its own output.
The strongest mechanism here refuses to let a session end and hands back the unwritten list. It fired eight times and produced one fact; one session it held open had made 118 edits. Structural triggering is reliable. Structural capture is not, because the last step still hands a model a choice.
Three coding agents share one graph here. A cross-tool recall reads the writer off the fact's own edge and the reader off the presented key, so the agent being graded cannot type its own evidence — and since 2026-09-13 the server refuses a fact no read ever returned.
Extraction happens in the calling agent, so storing a memory invokes no model here. The cost moved rather than vanished: this measures a server receiving facts somebody else already extracted.
And the ones that went the other way
Entity resolution leans on similarity between entity names. Calibrated against 155 pairs a human confirmed distinct and 11 confirmed identical, that similarity scores AUC 0.666, 95% CI [0.421, 0.881] — an interval that includes chance. So the unattended merge was switched off: at the automatic bar, precision was 50% over two reviewed pairs, and the audit log showed that path had fired once in the system's entire history. A near-match is now offered for confirmation instead.
echo-memory calibrate recomputes it on your own store.
Built for one pain, aimed at a wider one.
A developer running local agents who wants Claude Code, Cursor, or anything else to stop losing context between sessions and tools.
A team running agentic systems in production — support bots, DevOps agents, internal tooling — that needs one shared memory layer instead of N disconnected ones, scoped correctly per agent, per team, or org-wide.
Early and staged, on purpose.
The validated wedge driving v1a is cross-tool coding agent memory — the founder's own daily pain, real and tested. Everything else is the target this architecture is built toward.
Basic recall
Six MCP tools and thirty echo-memory commands, on PyPI and in the official MCP registry. Writing, recall, the audit trail, the ingestion queue, and record_recall_save — which now refuses a fact no read ever returned.
Causal typing + multi-hop
Retrieval that walks the graph rather than only ranking facts in it. Not shipped, but no longer unmeasured: 187 questions that no single fact answers now score MRR 0.212, and a one-hop expansion improves what is reachable while costing what is read first. The number it has to beat exists before the feature does.
Org-wide tenancy
The scoping model the broader vision depends on: per-agent, per-team, or organization-wide graphs.
Open at the core. Paid to run it.
The self-hosted edition is not a trial and will never be crippled to sell the paid one. Everything a single developer needs stays open, permanently.
Everything a developer running local agents needs. Your database, your machine, your data.
- Unlimited facts, episodes, and projects
- MCP server, CLI, dashboard, session hooks
- Cross-tool recall — Claude Code, Cursor, any MCP client
- The full graph, clustering, and audit log
The same memory, without the Postgres. We run the database and the extensions; you point an agent at a URL.
- 250,000 units a month — a unit is one fact written or one fact returned
- Managed Postgres with pgvector and Apache AGE
- Hosted MCP endpoint — no local install
- One memory across every machine you work on
- Dashboard at a URL, with backups
Anything past the Cloud plan: a higher ceiling or none at all, more than one person on one memory, and the questions that come with both — who can see what, and what should never have been written down.
- Volume above 250,000 units a month, or uncapped and invoiced
- Org, team, and per-agent scoping
- SSO and SCIM, role-based access per scope
- Secret and PII redaction before write
- Audit-log export and retention policy
Skip the Postgres.
One email when hosted Echo Memory opens, and one when Team does. No newsletter, no drip sequence.
Two commands. Either door.
Echo Memory is a Python package and a Postgres database. Install it once per machine and every agent you wire up writes to the same graph.
# run it yourself — nothing leaves your machine pipx install echo-mem echo-memory quickstart # starts the database, applies the schema, prints the line that registers it # Docker is the only prerequisite — the Postgres image is published, nothing compiles # or use the hosted service and run no database at all echo-memory connect <key> # a key from api.echo-mem.com # then, once per machine, so agents know when to record and recall echo-memory install --global # restart your client afterwards: an MCP server holds the code it started with
echo-mem 0.3.0the implementationio.github.ayushcodes10/echo-memboth doors: the package and the hosted endpointecho-memname held for a future JS clientNot `echo-memory`. That name belongs to an unrelated hosted product on PyPI, published March 2026. pip install echo-memory installs theirs, not this. The import package here is still echo_memory; only the distribution name differs.
echo-memory status reports what each scope holds and which agents have written to it. If only one agent is listed, memory is not yet shared and it will tell you so.