Memory,
folded into
your agent.
Know what sales promised, before support replies.
Anona Memory Public beta is a managed memory layer for AI agents. Record what happened, Retrieve what matters, and Reason across everything a space knows.
$ pip install anona$ npm install @anona-labs/memory
Read https://docs.anonalabs.com/llms.txt and add Anona Memory to this project. Sign up at https://memory.anonalabs.com for an API key, then point my client at https://api.anonalabs.com/v1 with the X-Anona-Space-Id header set to this app's space.
Your agents learn. Your company doesn't.
AI Agents remember more than they used to. What they learn still stops where the vendor stops. It does not reach your API calls, the next tool your team opens, or the colleague sitting beside you. Giving agents memory yourself means running infrastructure that is not your product:
Anona Memory folds all of it behind one memory.
We do the undifferentiated heavy lifting so your team can build the product.
What one agent learns should not sit locked inside that agent, tied to the model it happened to run on. It belongs to your company. Every agent you point at a space reads and writes the same memory, whatever model is behind it. Export the whole space to Markdown, JSONL, or its entity graph whenever you want it out.
Facts go out of date. Someone changes jobs, and memory that never resolves the conflict keeps answering with the old title. Anona Memory keeps the current answer and stores what it replaced, with the date it changed. You can also ask what a space knew on any past date, so in September you can still explain why the agent answered the way it did in June.
Three operations.
The rest when you want it.
- Record
- Store what happened.
- Anona pulls out the durable facts and indexes them for meaning. When a fact changes, the new version answers; the old is kept with its date.
- Retrieve
- Get back what matters.
- Ranked by meaning, not keyword overlap. Take the list, or one prompt-ready block cut to your token budget.
- Reason
- Ask for the conclusion, not the evidence.
- Some answers live across many memories. Reason runs an agentic pass over the space, links related facts, weighs what is recent, and returns one answer. The fuller the space, the better."What have we learned about Alice's career?"Alice moved from junior to senior engineer over six years, specializing in distributed systems, and mentorship.
Also in the API:documents and RAGcontext receiptsthe entity graphuser profilesextraction settingswebhooksexport
Every crease stays
in the paper.
Unfold any origami model and every crease is still in the paper. Give someone the pattern and they can fold the shape again. The memory is the crease pattern: the part that compounds, and the part your company owns.
Everything a memory layer needs, pre-folded.
Pick a capability to see the real call. Every one of these is live today.
"Where does Alice work?", "Alice's employer", and "What company is Alice at?" all surface the same memory. Anona generates and indexes every embedding; there is no model to choose or host.
curl -X POST https://api.anonalabs.com/v1/retrieve \ -H "Authorization: Bearer anona_live_YOUR_KEY" \ -H "Content-Type: application/json" \ -d '{"space_id": "customer-support-bot", "query": "Where does Alice work?"}' # Each result carries content, relevance_score, memory_type,# entities, occurred_start, created_at, and its scope ids.Three calls.
That's the integration.
Record and retrieve your first memory in five minutes. Or change your base URL and let the proxy remember for you.
- Python and TypeScript SDKs; every Python method has an async counterpart.
- A drop-in proxy for OpenAI, Responses, and Anthropic Messages clients. Streaming included.
- An MCP server for Claude Code, Claude Desktop, Cursor, and Hermes Agent, with no integration code.
from anona import AnonaClient client = AnonaClient(api_key="anona_live_YOUR_KEY") client.record( space_id="support", content="Alice is a senior engineer at Google",)client.retrieve(space_id="support", query="Where does Alice work?")client.reason(space_id="support", query="How has Alice's career progressed?")Works with what you already run.
Six Python adapters, two TypeScript adapters, an MCP server, and a proxy that speaks the client shapes you have. Every adapter fails open: memory failures never raise into your agent.
Python adapters
pip install "anona[langchain]", one extra per framework
TypeScript adapters
npm install @anona-labs/memory
MCP clients
Remote server at memory.anonalabs.com/mcp, key or OAuth
Drop-in proxy clients
Change the base URL, keep the SDK you have
Models your reason and chat calls can run on
Every model on every plan. No plan gate.
Third-party names and marks belong to their owners and are shown to identify the integrations the docs describe.
Loops that get better every turn.
A company is a set of loops. Give each one a shared memory and the thousandth turn beats the first. Not every loop needs all three calls, and what one loop records another one reads.
Coding loop
- record
- "[payments-api] Auth moved to the gateway. Per-service auth rejected: the token refresh raced under load."
- retrieve
- "how is auth handled"returns Auth is at the gateway. Per-service was rejected for a token refresh race.
- outcome
- A different agent, three weeks later, stops re-proposing what the team already rejected.
Support loop
- record
- "[Acme Corp] Refunds failing. Their card issuer blocks 3DS retries. Manual capture works."
- retrieve
- "open issues for this account"returns Refund retries fail at Acme's card issuer. Manual capture is the workaround.
- outcome
- The customer never explains it twice.
Sales loop
- record
- "[Acme Corp] Champion left. New VP wants SSO before renewal. A competitor is in the account."
- reason
- "what does Acme need before renewal?"returns One answer across a year of calls, citing the memories behind it.
- outcome
- Slippage shows before the forecast call, not after it.
Incident loop
- retrieve
- "connection pool exhausted on checkout"returns Same signature in March and July. Both fixed by raising the pool ceiling.
- reason
- "has this broken before, and what fixed it?"returns Cause, resolution and open actions, with citations.
- outcome
- The pager wakes one person instead of five.
Research loop
- record
- "[memory-vendors] Vendor A benchmarks recall on their own eval, not LongMemEval, so their number and the one B published are not comparable."
- reason
- "what do we know so far, and where do the sources disagree?"returns One answer with the conflicts named and cited.
- outcome
- Forty sources become one answer you can defend.
Built for agents that are already in front of users.
For teams putting agents into production, where what an agent learns has to outlast the model it ran on.
- AI product developers
- User-facing agents that remember context across sessions: preferences, history, decisions.
- Platform teams
- Internal assistants that accumulate what a team knows instead of re-asking for it.
- Founders and engineering leaders
- One memory the company owns, so what agents learn survives a change of model or a change of tool.
Your agents learn. Start keeping it.
Free to start, no card. Export everything whenever you want out.
Anona Memory is in public beta. Features and APIs may change, so keep exports of anything critical. The terms say the same.
Five minutes, start to finish.
- 1
Sign up at memory.anonalabs.com and create an API key.
- 2
Create a space, the boundary for one app or tenant.
- 3
Record and retrieve your first memory.