The .dai format · open spec · Apache 2.0
Your AI's memory, as files you own.
.dai is open-format memory for LLMs, AI assistants and agents: your day-to-day Claude and ChatGPT use as much as your own agent. Every conversation becomes a readable .dai file on your machine: one open format that Claude, GPT, Gemini, local models and any other LLM can read from and write to. Cut what you spend on API calls, stop maxing out your usage limits. No memory server, no vendor, no lock-in.
$ git clone https://github.com/Kerneta/daidocs daidocs-app
$ cd daidocs-app
$ node setup.jsNode 18+. Three lines, each its own command: node setup.js installs the dependencies on its first run and then configures Claude Desktop, Claude Code and the session hooks in one pass, backing up every config it touches. Full install guide
* LongMemEval-S, the official 500-question chat-memory benchmark, scored by the benchmark authors' own evaluate_qa.py against judge snapshot gpt-4o-2024-08-06, GPT-4o answering in every arm. A question reads a mean of 10,065 tokens out of a folder of text files instead of 103,601 pasted into the window, counted with the same tokenizer on both sides. Converting costs $0.0009 per 1,000 tokens with an API key, or nothing on a Claude subscription. Only Mastra OM scores higher, at 84.80%. Every competing score, with its caveats · Work out your own saving
One document format
for every model.
PDF made documents portable between programs. .dai does the same for AI memory. It is a plain-text container with three zones, so a machine can parse it and a human can read it. Every .dai file uses the same format, which means your memory outlives any single model, vendor or subscription.
Five things you gain,
and the one thing it costs.
In plain terms, with the measured number beside each one.
Your project stops hitting the wall
Work past the 1M limit
Claude Code with Opus gives you a 1M-token window. Today, when your project fills it, that is the end of the conversation: you start again and lose the thread.
With .dai, the window is no longer the limit. Your history lives in files, and each question reads only the handful of pages it needs, so a project several times larger than the window keeps working normally. The store keeps growing. What the model reads does not.
Measured up to a 1M-token history. Beyond that it is the same mechanism at work.
The same work costs a fraction
Up to 10× fewer tokens
Today you re-send your whole history with every question. With .dai the model reads a mean of 10,065 tokens instead of 103,601: the same answer, a tenth of the reading.
In money: 100 questions against a 500k history on Sonnet 5 costs $156 today, or $14.09 with .dai, conversion included. Work out your own numbers
The saving grows with your history. At 50k tokens it is only 1.4×, and below about 20k it is not worth converting: measured at a 22k history the engine reads the originals verbatim and returns more tokens than the history holds, so there is nothing to save there.
It makes fewer mistakes
22 points more accurate
The same model, the same 500 questions. Reading a pasted history it gets 60.60% right. Reading .dai it gets 83.00% right, which is a third more correct answers.
This is the part people find surprising: giving a model more raw history makes it worse, not better. Details drown, dates blur, and it says "I don't have that" while the answer sits in its own window.
So the bigger and longer-running your project, the more mistakes you are already living with, and the more a clean, dated store is worth.
One memory, every model
Files you can share and move
Your memory is plain text files on your disk, not a database and not a service. That means Claude, GPT, Gemini, Cursor and a local model can all read the same store, at the same time, with no export step between them.
Copy them to a teammate, put them in git, sync them to your own cloud, or keep them on the machine and let nothing leave it. Nothing is locked to one vendor: the format ports everywhere, so you can move between models, or use several at once, without exporting or rebuilding anything.
Your subscription goes further
More left to spend
If you have ever hit a Claude or ChatGPT usage limit mid-task, this is the practical benefit. Every question that reads a fifteenth as much leaves that much more of your allowance for actual work, and on the API the same mechanism shrinks the bill instead.
The same plan carries you either much longer, or through a much bigger project, without paying for a higher tier. Recall itself spends nothing at all: it is code reading an index, not a model call.
What it costs you
One conversion, paid once
Converting a conversation is a single model call: about $0.0009 per 1,000 tokens, or nothing if you point it at a model running on your own machine.
It is paid once, no matter how many questions come afterwards. There is no subscription needed to read your own files, and no charge for recall, ever.
How long before you hit the wall today
Take a history growing at 150,000 tokens a week, which is heavy daily use. Pasting it into a 900k-token window, you fill that window in about six weeks, and the project stops.
At that same six weeks, a .dai store of the identical history reads about 15,000 tokens a question: under 2% of the window you just exhausted. You are nowhere near the wall, and the work carries on.
A folder of text files.
That's the whole trick.
No vector database. No memory server. No embedding pipeline to babysit. Your memory is ~/DaiDocs: one readable file per conversation, an index the retrieval code reads, and byte-exact originals of everything ever saved.
- Readable. Open any memory in Notepad. Explorer is the memory browser.
- Greppable and git-able. Search it, diff it, version it, back it up like any folder.
- Portable. The same store serves Claude, GPT, Cursor, Windsurf and local models. The format ports; the accuracy does not. On identical stores and one shared set of prompts, five answering models spanned 14.0 points, from 78.00 with Claude Haiku 4.5 to 92.00 with Claude Fable 5 (460/500).
- Lossless. Originals stay byte-exact in
_raw/, verified before anything else runs. Never deleted.
DaiDocs/ ├── YYYY-MM-DD_bug-investigation.dai ← one file per conversation ├── YYYY-MM-DD_roadmap-planning.dai ├── YYYY-MM-DD_architecture-notes.dai ├── _index/ ← what retrieval reads │ ├── manifest.jsonl │ ├── facts.jsonl │ └── events.jsonl ├── _unconverted/ ← not converted yet, small, │ └── … read by the next session └── _raw/ ← byte-exact originals, └── … never deleted
- Works across every model. One store serves Claude, GPT, Gemini, Cursor and local models at the same time. The same files, no export step, no per-vendor copy.
- Outlives the tools. Readable in any editor in ten years, by software nobody has written yet.
- Yours. Leave anytime. Your memory comes with you, because it was never anywhere else.
Recall reads kilobytes, not your whole history.
We consume 3.0× fewer tokens than the system ahead of us on the benchmark, and sit second among memory systems whose configuration is reproducible, 1.80 points behind it on the same answering model.
Nearly the same accuracy. A third of the context.
LongMemEval-S, 500 questions, GPT-4o answering both. Ranks are among memory systems whose configuration is reproducible. Two measures in different units, so each gets its own plot and its own scale.
Same answering model, so the memory is the only thing that differs. They are ahead by 1.80 points, which is 9 questions out of 500. We read 3.0× less context to get there.
Both accuracy figures are LongMemEval-S with GPT-4o answering, which is the only way to compare two memory systems rather than two frontier models, and both are micro-averaged over all 500 questions. Averaged by task instead, it is 84.23 against our 84.02, a gap well inside a single run's noise. Mastra's own headline is higher: 94.87% with gpt-5-mini, and 93.27% with gemini-3-pro. We have not run those actors against their system, and our best actor result is 92.00% with Claude Fable 5. Their 30,000-token context figure is their own published one; ours is measured. Token figures are per-question averages at GPT-4o input pricing. Full table and caveats
Different from Claude's and ChatGPT's own memory
Built-in app memory is vendor-bound: it cannot follow you between assistants, and you cannot open it as files.
One .dai store serves Claude, ChatGPT, Cursor and local models, and it stays readable as files whichever assistant you open next. There is no memory server holding it, because the store is a folder you own.
Built for the work you come back to
.dai is designed for real work: a project you are building, an app you are shipping, a customer whose history you need next month.
The turning point is around 15,000 to 20,000 tokens of history. Below that, converting is not worth it and the decision layer just reads your text as it is. Above it, every answer comes from files you own.
One store.
Any assistant, any agent, any model.
Your memory is a folder of text files, so nothing about it is tied to one vendor. Anything that speaks MCP mounts the same store: Claude Desktop and Claude Code, Cursor, Windsurf, the OpenAI Agents SDK, the Anthropic API, or your own agent. All of that runs locally and free today. Hosted surfaces (claude.ai web, ChatGPT connectors, mobile and org-wide provisioning) need Kerneta Cloud, which is in waitlist.
See what you have: the memory map ships now
Every store and what it costs on disk, what is still waiting to be converted, each memory as its own page, the file in its three zones beside the untouched original, search, and the folder settings that otherwise mean a terminal. One command in the install folder builds it as a single page that works offline, npm run dashboard: it writes daidocs-dashboard.html and prints the path, and you double-click that file. It holds your memories in full, so it is built by you and never shipped. The recording uses invented data.
Agent memory over MCP ships now
Claude Code, Cursor and Windsurf sessions read and write the same store over MCP (save_memory, recall_memory, list_memories, read_memory, declare_project, brief_parent), and the hooks turn every session into memory as you work, every 4,000 tokens, without being asked. Unlike hosted memory layers, there is nothing to deploy and nothing to subscribe to: the store is a folder.
Claude Desktop ships now
Say "save this chat to memory". Later, in any new chat, just ask. Recall runs in about 10k tokens of context on your subscription.
Claude Code ships now
Every session saves itself: every 4,000 new tokens and again at the end, with no API key on a Claude subscription. Close early and the unconverted part waits in _unconverted/, read in at the start of the next session in that folder, so it is usable before it is converted.
API and Agent SDK ships now
Point any MCP-capable agent at the server, or back Anthropic's native memory tool with the .dai store.
Cursor, Windsurf, OpenAI Agents SDK ships now
Same server, same store, any MCP client. One memory across every assistant and agent, whichever company built it.
Web, mobile, teams cloud · waitlist
A hosted connector will bring your store to the browser and phone, with shared vaults, SSO and an audit log for teams. It is not available yet.
Archive a session.
Open a new window. Ask.
The strongest demo is the boring one. With the Claude Code hook installed, the session you are reading right now would archive itself the moment it ends. Tomorrow, a fresh session recalls it without re-reading the whole history.
> what did we decide about the build failures last week? ● daidocs-mcp · recall_memory("build failure decision") └ YYYY-MM-DD_bug-investigation.dai · 8.2k tokens Last Tuesday we traced the flaky deploys to the cache step and decided to pin the builder image, then move secrets to the runner env. You wanted a rollback alias, still open. ✓ recall: no model call, answered on your subscription
A format is only useful if everyone can read it.
So .dai is open, the spec is public, and the reference implementation is Apache 2.0. Kerneta builds the tools; the format belongs to everyone. This is the first of several things we are shipping on it.