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
checkout-api, mobile-app and data-pipeline were recorded in separate sessions. The picture already separates them, because separation is a property of the edges, not a label anyone applied. data-pipeline sits apart on the left: nothing it knows touches payments.
Everything it takes part in
idempotency keys is the concept that joined two codebases. The panel shows it referenced from checkout-api twice and mobile-app once — three facts, one node, resolved by matching an existing name rather than creating a duplicate.
Why memory believes it
This is what a knowledge graph gives you that a code map can't. A superseded fact is never deleted — it stops being drawn, but stays reachable from its node 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_logBuilt 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
write_episode, query_memory, get_audit_log, the MCP server, and the echo-memory CLI are running today.
Causal typing + multi-hop
Relation-typed edges and Personalized PageRank retrieval across the graph, not just single-fact recall. Deliberately not started: v1a has to demonstrate that recall earns its keep first.
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.
- 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
What changes when more than one person shares a memory: who can see what, and what should never have been written down.
- 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.
One install, every project.
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.
# 1. the database — Postgres with Apache AGE and pgvector git clone https://github.com/ayushcodes10/echo-mem.git && cd echo-mem docker compose up -d # 2. the package pip install echo-mem # 3. the schema — reads the migrations out of the installed package export ECHO_MEMORY_DATABASE_URL="postgresql://postgres:postgres@localhost:5433/echo_memory" echo-memory init-db # 4. wire it into Claude Code, user-scoped claude mcp add --scope user echo-memory \ -e ECHO_MEMORY_USER_ID=your-user-id \ -e ECHO_MEMORY_AGENT_ID=claude-code \ -e ECHO_MEMORY_DATABASE_URL="$ECHO_MEMORY_DATABASE_URL" \ -- python -m echo_memory.server # 5. wire every other MCP client on the machine echo-memory adopt # shows the diff echo-memory adopt --apply # Claude Desktop has no config file to write - give it the skill echo-memory skill --package .
echo-memthe implementationecho-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.