One shared brain for your AI agents
Your agents forget.
Klio remembers.
Klio is one shared memory that every agent plugs into — Claude, Cursor, Codex, and any MCP agent. What one figures out, they all know. So your agents stop forgetting, repeating work, and contradicting each other.
$npx @klio-tech/klio initView on GitHubLocal-first · encrypted under your key · open source
Connect any agent
The problem
Passes every eval. Ships. Then quietly drifts.
No crash, no alert — the agent just starts doing 90% of the job instead of 100%. The root cause isn’t the model. It’s that the agent has no memory: it can’t remember across sessions and can’t share context across tools.
Forgets between sessions
Every session starts from zero. You re-paste the same context, the same conventions, the same decisions — again.
Agents don’t share what they learn
Cursor figures something out; Claude Code has no idea. Two agents on one project, two separate blank slates.
Re-makes decisions you already made
It re-introduces a bug you fixed last week and contradicts an architecture call from yesterday. No memory, no continuity.
How it works
Capture once. Recall everywhere. Drift goes down.
Capture
Klio records what happens in a session — decisions, observations, notes — over MCP and a few lightweight hooks. No copy-paste.
Recall
Before acting, the agent calls recall() and gets the relevant prior context back — scoped to the project, shared across every agent on it.
Stay reliable
With continuity, the agent stops re-deriving, re-deciding, and re-breaking. Drift and repeated mistakes fall because the context never left.
The toolkit
Seven MCP tools your agents already know how to call.
MCP-native — no SDK to wire, no framework lock-in. Any MCP client gets these verbs out of the box.
recall(query)Pull the relevant prior context before acting.remember(fact)Persist something worth keeping across sessions.observe(event)Log what happened — raw session activity.plan(intent)Record the plan so the next agent builds on it.decide(choice)Capture a decision so it isn’t re-litigated.note(text)Jot a durable note scoped to the project.space(name)Open or switch a scoped memory store.Why it matters
Memory is why agents stay reliable.
Drift, hallucination, and repeated mistakes are all downstream of the same thing — the agent forgot. Observability tools flag these after they happen. Klio prevents them by giving the agent its context back before it acts.
Private by default
Your agents’ memory never leaves unless you say so.
A memory layer sees everything your agents do. So Klio is built to keep it yours — local-first, encrypted under your own key, and auditable end to end.
Local-first
The engine runs on your machine. Nothing leaves it unless you opt into Klio Cloud.
User-owned key
Memory is encrypted at rest under a key you hold — not us, not a shared cloud tenant.
Cryptographic audit
Every write is chained with SHA-256. The history is inspectable — “trust us” isn’t in the design.
Zero telemetry
No usage phone-home. What your agents remember stays between you and your agents.
How Klio compares
Most memory tools recall for one agent. Klio is the shared brain.
| Capability | Klio | mem0 | Zep | Supermemory |
|---|---|---|---|---|
| Cross-agent shared memory | ||||
| Local-first (runs on your machine) | ||||
| Encrypted under a user-owned key | ||||
| MCP-native | ||||
| Open source |
Klio Cloud
Don’t want to self-host? Klio Cloud is live.
The same memory layer, fully managed — zero infrastructure, cross-agent sync, and per-end-user memory for teams embedding Klio. Free to start; you only pay when we host at scale.
Managed & backed up
Hosted memory with no Postgres or Redis to run. Start in seconds.
Cross-agent sync
Shared memory across every agent and machine on a project, in real time.
Per-end-user memory
Embedding Klio in your own product? Give every user private, isolated memory (priced per end-user).
SSO & audit
Team access, single sign-on, and a cryptographic audit trail.
Pricing
Start free. Scale when your agents do.
Free
Start sharing memory across your agents.
- Memories captured1,000 / mo
- Recalls10,000 / mo
- Cross-agent syncLocal only
- Connected agentsUnlimited
Starter
For solo devs running a few agents together.
- Memories captured25,000 / mo
- Recalls100,000 / mo
- Cross-agent syncReal-time
- Connected agentsUnlimited
Pro
PopularFor teams whose agents work together daily.
- Memories captured150,000 / mo
- Recalls1,000,000 / mo
- Cross-agent syncReal-time
- Connected agentsUnlimited
Team
For organizations running many agents at scale.
- Memories captured1,500,000 / mo
- Recalls10,000,000 / mo
- Cross-agent syncReal-time + priority
- Connected agentsUnlimited
Platform
Per end-userEmbed Klio in your own product and give every one of your users their own private, isolated memory. Cross-agent sync, per-user isolation, SSO, and a cryptographic audit trail.
Or self-host the open-source engine — free, forever, on your own machine. Get it on GitHub. See full pricing.
Questions, answered honestly
FAQ
What is Klio?+
Klio is a memory layer for AI agents. It captures what your agents learn, stores it encrypted under a key you own, and serves it back through MCP so your agents remember across sessions and share context across tools — which is what keeps them reliable.
Does my data leave my machine?+
No. Klio is local-first: memory is stored on your machine, encrypted under a user-owned key. Nothing leaves unless you explicitly opt into Klio Cloud.
How is Klio different from mem0, Zep, or observability tools?+
Memory tools like mem0 and Zep recall for a single agent. Observability tools watch output after the agent acts. Klio gives multiple agents a shared, persistent memory — preventing drift at the source instead of recalling for just one agent or flagging problems after the fact.
How long does it take to set up?+
One command: `npx @klio-tech/klio init`. It wires Klio into Claude Code, Cursor, or Codex and starts remembering from the next session.
Which agents does Klio work with?+
Klio is MCP-native, so it works with Claude Code, Cursor, Codex, and any MCP client out of the box.
Can I change the embedding model?+
Yes. Embeddings are pluggable per space — nomic-embed-text by default, with snowflake-arctic-embed2, OpenAI text-embedding-3-small, and others supported. Pick the model that fits each store.
Does Klio run on Windows?+
The self-hosted engine runs anywhere Docker does, including Windows via WSL2. If you’d rather not run anything locally, Klio Cloud works from any OS with zero install.
Is it really encrypted?+
Yes — memory is encrypted at rest under a key you own, and every write is chained with SHA-256 so the history is tamper-evident and inspectable. It’s auditable by design, not “trust us”.
Give your agents a memory.
One command wires Klio into Claude Code, Cursor, or Codex. It starts remembering from the next session — and never ships your data out.
$npx @klio-tech/klio initOr sign up for Klio CloudPrefer the source? Star it on GitHub