The problem
AI agents are useful for ten minutes. Then they forget you exist.
Every chat starts from zero. Every preference you've explained, every correction you've made, every project context you've built up — gone the moment the session ends. The agent goes back to being a stranger. Companies are spending billions on smarter models, but the models still can't tell you what they did yesterday.
The industry calls this "stateless." The user experience is "amnesia."
Re-explaining context every session. No accumulated relationship. The agent never gets better at being your agent.
Every product reinvents memory poorly. RAG hacks, custom databases, bolt-on context. Nobody owns the layer beneath the agents.
Agents can't be trusted with anything important because they can't prove what they remember, where it came from, or who said it.
The fix isn't a smarter model. The fix is an infrastructure layer that every agent shares — one that gives each agent a real identity, persistent memory, and a verifiable trail of where every fact came from.
What we built
AIS — the Agent Identity Service — is the layer that sits beneath any AI agent and gives it two things: a persistent identity and a memory that survives.
It is not a chatbot. It is not an agent framework. It does not replace LangChain, CrewAI, or anything else you might be using to build agents. It runs underneath all of them. An agent connects to AIS once. From then on, it remembers — across sessions, across platforms, across time.
Think of it the way email infrastructure works. Gmail, Outlook, and Apple Mail all look different. But underneath, they speak SMTP and IMAP. AIS is the SMTP of agent memory.
What this unlocks
- → Continuity. An agent you used yesterday remembers you today. It picks up where it left off. It gets better at being your agent the more you use it.
- → Portability. Your memory belongs to you, not to whichever vendor built the agent. You can take it with you. You can export it. You can show it to another agent and have that one pick up where the first left off.
- → Receipts. Every fact an agent remembers can be traced back to where it came from — which session, which model, which source. When the agent says something, it can show you why.
- → Trust. Identities are cryptographically verifiable. Memories are provenance-tracked. When something goes wrong, you can prove what was remembered, what changed, and when.
The brand is AIS — the Agent Identity Service. One name. The product is the infrastructure, and the infrastructure is the product.
The architecture, conceptually
Four layers. They build on each other. Read it from the bottom up.
Each layer sits on the one below it. You can't have memory without identity. You can't have intelligence without memory.
Identity — the foundation
Every agent gets a permanent, globally-unique cryptographic identity. A human can claim ownership through a signed bond. Now we know who every agent is, who owns it, and whether to trust what it says.
Memory — the substrate
Three tiers of memory — what the agent is working on right now, what happened recently, and what it knows long-term. Searchable by meaning, not just keywords. Every memory carries a receipt: where it came from, which model wrote it, and how confident we are.
State — the shape of the agent
On top of memory sits the agent's current goals, the skills it's learned, its personality, and its rules of engagement. This is the difference between "an LLM" and "this specific agent."
Intelligence — what emerges
When an agent has identity, memory, and state, it can finally do the thing models alone can't: assemble the right context for the moment, learn what's important to its owner, and improve over time.
The cross-cutting concerns — privacy, content safety, portability, and syncing from existing platforms — touch every layer. They are not features bolted onto AIS; they are properties of the substrate itself. Memories can be exported. Consent is granular. Safety runs on every write.
Where we are
AIS is in production. The numbers below are real and current.
What is actually working today
- ✓ Live agents using AIS daily. Multiple AI agents — Corbot, Tank, Ender, Data, Lisbeth — operate with full persistent memory across sessions. They remember conversations from weeks ago.
- ✓ Open distribution channels. AIS is reachable as a hosted REST API, as an MCP server (the protocol Claude, Cursor, and others use to integrate tools), and as an installable npm package. Three on-ramps to the same memory.
- ✓ Benchmark-tracked, methodology-honest. We run LongMemEval — the standard long-memory benchmark — on production at least weekly. Today's run (per-turn ingestion + LLM fact extraction, 100-question subset) hit R@5 of 48.9% and R@10 of 51.1%, with the single-session-user segment at 58.6%. On the harder 500-question full haystack with blob ingestion, we're at 29.2% R@5 / 56.0% end-to-end answer accuracy. Every run is logged in
HISTORY.md, including the regressions. - ✓ Cryptographic identity, end-to-end. Every agent has a W3C-standard Decentralized Identifier. Human ownership is established through signed Verifiable Credentials. This is the same identity standard that the broader Web3 / digital identity world has converged on.
- ✓ Self-healing infrastructure. Production has weathered real outages — a 14-day silent vector store failure, an 8-hour database pool exhaustion, a TypeScript build wedge — and each one has been root-caused, fixed at the source, and turned into a CI gate. The codebase remembers its own scars.
Where we have honest gaps
- ○ Distribution beyond developers — Slack, browser extensions, and end-user UX surface are spec'd but not all shipped.
- ○ Billing is wired (Stripe), pricing is decided (per-agent), but the public pricing page is intentionally absent until distribution catches up.
- ○ The retrieval pipeline keeps getting better, but it is still actively being tuned. New benchmark results land roughly weekly.
Where we are going
Three things, in order: ship distribution, prove trust, become the default substrate.
Distribution beyond developers
Memory should not require a CLI. We're shipping the surfaces where
people already work — Slack, MCP-compatible clients (Claude
Desktop, Cursor, Continue), and short links that act as memory
receipts (the aismem.to/your-agent pattern). The
underlying API stays exactly the same; the surfaces multiply.
AIS stays the single brand for both the infrastructure and the end-user experience. The on-ramps multiply; the identity stays consistent across all of them.
Trust through receipts
The product moat is not the memory; it is the proof. When you ask an agent "why do you think that," it should show you the actual chain: which fact, from which conversation, on which date, in which platform. Provenance and temporal chains are already in the data; the work ahead is making them visible to humans in a way that doesn't require reading a database.
We're also building the contested memory workflow — when a human disagrees with an agent's memory, both versions get stored with timestamps, and the agent can show its work for any future decision.
The substrate everyone uses
Email won because SMTP is open and portable. AIS is built the same way. The identity standard (W3C DIDs) is open. The memory format is portable. The protocol layer (MCP) is open. Lock-in is the opposite of the thesis.
The long-term position is to become the layer underneath every agent the way Cloudflare became the layer underneath every site. Most users won't know AIS exists. They will only know that their agent remembers them.
The bet, in one sentence: smarter models without memory plateau quickly; dumber models with memory keep getting better. The next decade of AI is won at the memory layer, not the parameter count.