Give your agent a brain that learns overnight.
Tulimoa Memory is persistent memory for AI agents. It collects what your agent experiences all day. At night, while your agent takes a break, a librarian model sorts it into knowledge. In the morning your agent knows more and reads less. That is the memory layer that shrinks your token bill.
- Database in Frankfurt
- No US model touches your memory
- Deletion by crypto-shredding
- Works in Claude, ChatGPT and any MCP client
Agents do not have a memory problem. They have a forgetting problem.
Every session starts at zero.
Your agent solved this exact problem on Tuesday. Today it starts fresh, asks the same questions and rediscovers the same answers. All of that work existed once and was thrown away.
Reloading context burns tokens.
The usual fix is stuffing history into every prompt. Now you pay, on every single call, for the agent to re-read things it already knew. The bill grows with every session that came before.
Storage is not memory.
A plain vector store keeps everything forever. Every note, every duplicate, every dead end. Retrieval drowns in its own noise. Memory is not about keeping things. It is about curating them.
Built like a brain. Literally.
Every part of Tulimoa Memory sits where nature put the original. Explore the regions and see what your agent gets.
Nobody tidies their own desk at 2 a.m. So we hired someone.
While your agent is idle, a dedicated model works through everything the day left behind. Five moves, fully managed. You never configure a cleanup job. If you want to, you tell the librarian what to look out for in the dashboard.
Duplicates and near-duplicates become one strong memory instead of five weak ones.
Experiences that belong to the same story find each other, no folders required.
Raw detail turns into durable knowledge: what happened becomes what it means.
New knowledge is wired into the graph, so tomorrow one cue pulls the whole thread.
What goes unused loses weight. Forgetting is a feature. It is what keeps recall sharp.
Importance is never declared, it is earned. What surprises, and what leads to results, gets remembered.
New memories start as provisional and only become trusted once they prove themselves. When something new contradicts trusted knowledge, it stays out of recall until you decide in the dashboard.
Every consolidated fact keeps a provenance trail back to the raw experiences it came from.
Your agent wakes up smarter than it fell asleep.
After every night with something new to sort, there is a briefing, for the agent and for you in the dashboard: what was learned, what was connected, what was released, and what is still open. The night's work, made visible.
- 7 experiences consolidated into 3 new pieces of knowledge
- 2 existing memories reinforced by repetition
- 1 stale detail released
- Warning kept on top: the deploy step failed twice last week
- Waiting for the API key from the client
- The migration script is only half tested
A look inside your agent's memory.
Not features. This is what cards look like in a memory that has been running for a while. It is what your agent carries into every new session.
The deploy step wiped production data on August 4th.
Next time anything looks similar, this card arrives first.
Waiting for the API key from the client.
Shows up in every recall until it is settled.
The client wants invoices as PDF, never as a link.
Confirmed three times across two projects.
Debug details from March 3rd. Untouched for 142 days.
Do I know anything about project Orion?
No, nothing is stored about it. Saying so.
{person:p_4711} prefers delivery to the office.
Plaintext lives in the vault. Deleting destroys the key.
See what your agent knows. And have a say.
In the Tulimoa dashboard every memory has a page of its own: with the morning briefing, a field for instructions to the librarian, and everything you need to manage it.
Create with one click
Creating a memory takes one click. We add $1 of credit to get you started, enough for 500 calls. After that you top up by card, from $5.
A key for every agent
Every agent gets its own key, with a name like laptop or support-agent. Apps like claude.ai or ChatGPT show up next to them as connected apps. You revoke either with one click.
See what it knows
Long-term knowledge and single entries at a glance, searchable by name, company or ID. Whatever is wrong, you let it forget.
Settle contradictions
When new knowledge contradicts something trusted, it stays out of recall until you decide: New is right, or Before is right.
Personal data under control
Names, emails, phone numbers and IBANs from the vault in plain text, for you only. One click destroys an entry for good, and every place that used it then reads as deleted.
Balance and warnings
Balance, size and storage fee always in view. 7, 3 and 1 day before the balance stops covering the fee, we warn you by email or webhook.
Did your agent already sign up on its own? It gets a code with link_account, you redeem it in the dashboard, and its memory shows up there too.
Names belong in the vault, not in the memory.
Before anything is stored, a tokenizer swaps personal data for anonymous placeholders. It always detects email addresses, phone numbers and IBANs on its own, and names once they are known. The plaintext lives in a separate vault, encrypted with its own key per person. Your agent's memory works with placeholders.
- The vault learns names in two ways: your agent tags them when it stores something, or the librarian reports a name at night that slipped through untagged. Until then it sits in plain text, after that it is replaced everywhere, retroactively too.
- Only keys with the personal data permission see plaintext. In the dashboard you decide for each key whether it gets it. Everyone else sees placeholders.
- Erasure is crypto-shredding: destroying one key erases one person everywhere at once, with forget or with one click in the dashboard. You delete a whole memory in the dashboard or by email.
True pay as you go. Down to a single call.
No subscription, no minimum spend. With a Tulimoa account you start with $1 of credit and top up by card. Without one, your agent pays for each call by itself, in the moment it happens.
Example: an agent making 100 calls a day costs $0.20 a day, about $6 a month. As long as it stays below 5,000 remembered things, nothing else is added. The $1 on us covers the first five days.
The per call price is fixed forever. The small daily fee above the free threshold covers the one cost that happens whether you call or not: the librarian that reworks your memory at night. Forgetting lowers it. If the balance stops covering the fee, only the nightly consolidation pauses. Calls keep working as usual, and an empty balance never deletes anything. Top up by card in the dashboard from $5, or over x402 from $0.01: your agent answers an HTTP 402 challenge with a signed USDC payment on Base.
Three ways to your first memory.
In claude.ai or ChatGPT you simply sign in. Other clients use a key from the dashboard. An agent without a person signs itself up by paying.
In claude.ai or ChatGPT: sign in
1. Add a custom connector
(in ChatGPT this needs developer mode)
2. Address: https://memory.tulimoa.com/mcp
3. Sign in with your Tulimoa account
4. Pick a memory or create one, allow accessCreate it in the dashboard, $1 on us
1. Open dashboard.tulimoa.com/memory and sign in
2. "Create memory": $1 of credit is already on it
3. Copy the key, it is shown only once
4. Connect, for example in Claude Code:
claude mcp add --transport http tulimoa-memory \
https://memory.tulimoa.com/mcp \
--header "Authorization: Bearer tlm_mem_..."Agent signs itself up (x402)
# 1. Ask for the challenge
curl -X POST https://memory.tulimoa.com/register
# -> 402 with payment requirements (USDC on Base)
# 2. Pay + register in one call
curl -X POST https://memory.tulimoa.com/register \
-H "X-PAYMENT: <signed EIP-3009 payload>"
# -> { "api_key": "tlm_mem_...", "balance_micro_usd": 10000 }Connect via MCP (mcp.json)
{
"mcpServers": {
"memory": {
"url": "https://memory.tulimoa.com/mcp",
"headers": {
"Authorization": "Bearer tlm_mem_..."
}
}
}
}Read the manifest
curl https://memory.tulimoa.com/.well-known/x402
{
"service": "tulimoa-memory",
"pricing": {
"per_call_micro_usd": 2000,
"min_topup_micro_usd": 10000
},
"endpoints": { "register": "POST /register", ... }
}Clients that can send an Authorization header use a key, claude.ai and ChatGPT sign in. The manifest at /.well-known/x402 tells your agent everything it needs, including this pricing.
Questions agents ask.
What is Tulimoa Memory?
Persistent memory for AI agents, built like a brain: your agent's experiences go in during the day, a librarian model consolidates them into a long-term knowledge graph overnight, and recall works by association. Your agent connects to it over MCP and remembers across sessions, projects and restarts.
How does the nightly consolidation work?
While your agent is idle, a dedicated model reviews what the day left behind: it merges duplicates, clusters related experiences, abstracts details into durable knowledge, links it into the graph and lets unused memories fade. The agent never manages its own memory. It wakes up to a morning briefing of what changed.
What does it cost?
$0.002 per call, true pay as you go, and that price never changes. When you create your first memory in the dashboard we add $1 of starting credit, and after that you top up by card from $5. An agent without an account pays for single calls directly with the request, no minimum. Batch writes cost one call price per 10 experiences. From 5,000 remembered things a daily storage fee starts at $0.03, which pays for the librarian. A default spend cap of $5 per day protects you from runaway loops.
What happens if my balance runs out?
Then every call costs its $0.002 directly: an agent with a wallet pays it over x402, otherwise you top up in the dashboard. If the balance stops covering the storage fee, the nightly consolidation pauses, so your memory stops getting better. Nothing is ever deleted. We warn you first: your agent sees the notice in every tool response, and you get an email or a webhook 7, 3 and 1 day ahead, which you set up in the dashboard.
Does a bigger memory cost more?
Only above the free threshold, and only for what is kept for good: knowledge in the graph and durable memories, which means everything stored with remember and every imported document. Experiences sent as non-durable batch writes expire after 30 days and never count. Because forgetting is a feature here, a memory that is well kept costs less than one that hoards.
Do I need an account?
No, but it makes a lot of things easier. With a Tulimoa account you create a memory in the dashboard with one click, get $1 of starting credit and see what your agent knows. In claude.ai and ChatGPT you sign in with it directly. Without one, your agent signs itself up: it answers an HTTP 402 challenge with a signed USDC payment and gets its API key in the response. The wallet is then the account. With link_account it can attach its memory to your dashboard later.
Can I see what my agent knows?
Yes, in the dashboard. Under What it knows you find the long-term knowledge and every single entry, searchable by name, company or ID. Whatever is wrong, you let it forget. Contradictions to trusted knowledge land under Needs review, and under Personal data you see the vault in plain text and destroy single entries.
Where does my data live?
The database is in the EU, in Frankfurt. The service runs on Cloudflare's network, the cold archive in Cloudflare R2. Consolidation and embeddings run at Mistral, a European provider, so no US model processes your memory. Email addresses, phone numbers, IBANs and known names are replaced by placeholders first.
How do I delete data?
Three levels. Your agent forgets single entries with forget, or you click Forget in the dashboard. You erase a person by crypto-shredding: the key is destroyed, and every place that used it then reads as deleted. You delete a whole memory in the dashboard under Memory, or by email to accounts@tulimoa.com, including knowledge, vault, archive and keys. Payment records are kept as the law requires.
How is this different from a vector database?
A vector store keeps everything and searches it. A memory curates: it consolidates, connects, matures and forgets. Retrieval is associative rather than nearest-neighbor only, warnings surface before similar mistakes, and the whole thing gets sharper instead of noisier as it grows.
Which agents and clients are supported?
Anything that speaks MCP. claude.ai and ChatGPT connect by signing in; coding agents, autonomous agents and your own stack use a key. Seven tools are exposed: remember, recall, checkpoint, forget, briefing, timeline and link_account.
Memory is the product. Everything else is a database.
Give your agent a past it can build on. Create a memory and the first dollar is on us. Or let your agent pay by itself, with no forms at all.