Free forever. Paid buys hands, not head-starts.
The complete local product is free, and the v4.4n engine stays Apache 2.0 for everyone, permanently. What we sell is service: we run it for you, we bring your past into it, and we sit with your team while they adopt it. Nothing here removes anything from Free.
One ratio behind every price: you pay 4× what a conversion costs in model tokens, and you keep the retrieval saving, which is the far larger number.
- Convert 3 chat histories into .dai files
- The full v4.4n engine under Apache 2.0, the one the headline number was measured on
- An API key, and the files to download and keep
- Chat history only, or self-host it and convert without limit, forever
- We run v4.4n for you, the same Apache 2.0 engine you could run yourself
- $5 of measured model cost, about 5.5 million tokens converted, then it stops
- Every document type: PDF, Word and chat exports, with structure repair
- Stores re-indexed on every engine release, and you can top up any time
- Everything in Starter, with higher rate limits and larger documents
- $20 of model cost, about 22 million tokens, four times Starter at the same ratio
- Every v4.x release runs for you as it ships, if and when one does
- Priority on new format parsers and extractors
- About $0.0036 per 1,000 tokens, 4× the measured cost of the GPT-4.1-mini observer
- Nothing to cancel, and nothing charged while you are idle
- Recall is never metered, because it spends no model tokens at all
- On the benchmark a question reads 10,065 tokens instead of a 103,601-token history
- Volume conversion pricing below 4×
- Your own observer model, including one running locally
- Data residency and retention terms in writing
- A named contact, and help moving an existing archive in
Conversions are metered on their measured model cost, never an estimate, and the meter is visible in your dashboard. Recall is never metered: it is index lookup and file reads, so it costs us CPU rather than tokens. Charging for it would contradict the architecture we are selling you.
Or pay nothing at all
The .dai spec, the v4.4n engine and the MCP server are open source under Apache 2.0, permanently, in one repository. Clone it, run daidocs-mcp with your own key or your Claude subscription, convert as much as you like, and never create an account. We charge for hosting, upkeep and team governance. Never for the format, and never for the engine. A memory format you have to rent is not a format you own.
Bring your whole history with you
Years of ChatGPT, Claude and Cursor conversations become readable .dai files on your disk, and they get smarter with every retrieval release because re-indexing is retroactive.
Total Recall importer · $29 launch price
One-time, $39 after launch, $19 for Starter and Pro subscribers. Converts your full ChatGPT, Claude or Cursor export to .dai. Unlimited conversations with your own key or your Claude subscription, and about 2,000 keyless conversations included. Dry-run count before any charge, per-conversation checkpointing, free preview of your first 100 conversations. Re-runs are free forever and it never requires an account: the license key arrives by email.
Indexing credit packs
$5 for 1,000 saves, $10 for 2,500. For people who want keyless indexing without a subscription. Credits never expire. Keyless calls travel through an open-source, zero-retention relay that forwards a save to the model provider and keeps nothing; the code is public and the deployment is auditable. Local paths (your own key, or your Claude subscription) remain the defaults and never touch us.
For organisations
Everything above is priced for one person's memory. A team's memory is a different product: the hard parts stop being conversion cost and become permissions, provisioning and knowing what the AI read.
Team
- Shared vaults, on your git remote or ours
- Per-file and per-agent permissions
- An audit log of what the AI read and wrote to memory
- Pooled conversion budget across the team
Enterprise
- Self-host, or your own cloud account
- Enterprise-managed auth (Okta and friends): one admin action provisions the whole organisation
- SSO, SLA, DPA, data residency
- Volume conversion pricing
Team and Enterprise are sold with their limits in writing before signature. If .dai is the wrong shape for your data (a single document that fits in context, for instance), the decision layer will say so, and so will we.
The engine is free and open. Paid is us running it.
The open engine is not a demo, and it is not an older edition: it is v4.4n, the complete local product, and its licence never changes. v4.4n is the only engine we publish a current result for: 83.00 on the official 500-question benchmark with GPT-4o answering, against 60.60 for putting the whole history in context with the same model. Earlier releases appear only as overall totals in the version ladder. Paid runs that same engine on our machines, plus the operational layer that keeps a store healthy as it grows: the part a copied repository cannot give you.
| Capability | Free · you run v4.4n · Apache 2.0 | Paid · we run v4.4n for you |
|---|---|---|
| Benchmark accuracy LongMemEval 500, GPT-4o answering, official judge | 83.00 | 83.00, the same engine |
| The .dai format and reader | Yes, forever | Same format, no lock-in |
| Retroactive re-index on new releases | You run the migration | Automatic, in the background |
| Structure repair | Plain text | PDF, Word, chat exports, machine-data repair |
| Line-unwrapping before ingest | Manual | Automatic |
| Store upkeep as it grows | Yours to manage | Dedup, merge, compaction, schema migration |
| Decision layer | Shipped snapshot | Updated as new measurements land |
| Licence | Apache 2.0 | Apache 2.0, the same engine |
v4.4n is open source under Apache 2.0, and it is the engine the 83.00 was measured on rather than a lagging edition. That is what keeps the number checkable without us: the dataset (LongMemEval-S) is a public academic benchmark, the engine is public, and the scorer is the benchmark authors' own evaluate_qa.py with the gpt-4o-2024-08-06 judge snapshot rather than a judge of ours. The protocol is docs/REPLICATION.md in the same repository.
Choose your answering model for accuracy. It does not change what conversion costs.
Converting is done once, by a small observer model. The model you later ask questions with never re-converts anything, so changing answering models moves your accuracy by up to 14.0 points without changing your conversion bill by a cent.
| Answering model | With .dai (v4.4n) | Context window | Effect on conversion cost |
|---|---|---|---|
| Claude Fable 5 | 92.00 460/500 | 1M | none |
| Claude Opus 5 | 91.00 455/500 | 1M | none |
| Claude Sonnet 5 | 85.60 428/500 | 1M | none |
| GPT-4o | 83.00 415/500 | 128k | none |
| Claude Haiku 4.5 | 78.00 390/500 | 200k | none |
| No memory system, whole history pasted (GPT-4o) | 60.60 | fails beyond the window | n/a |
Every model row is scored by the benchmark's own official judge on the same 500 questions, with identical stores, one shared set of rendered prompts and identical v4.4n retrieval. Only the answering model changes. The bottom row is the LongMemEval authors' own full-context GPT-4o result, 303/500. Two notes on this table. Fable 5 and Opus 5 are tied rather than ranked: five questions separate them, well inside one standard error of either. And the four Claude rows were run through a Claude subscription rather than over an API, so they carry no temperature 0 setting and the prompt reached the model as a file read; the GPT-4o row does have temperature 0. The format is portable across models. The accuracy is not: 14.0 points separate the best answering model from the worst.
Six weeks of pasting, and the same weeks through .dai
One developer, one project, Claude Opus 5. Project memory grows about 167,000 tokens a week (an illustrative rate, in the range we see on our own Claude Code sessions, not a measured average: put your own number into the savings page), and they ask questions as they build. Here is what happens.
How much you pay now: the whole history goes into every question
| Week | History | Read per Q | Per Q | T@10 Q | T@25 Q | T@50 Q | T@100 Q | T@250 Q | T@500 Q |
|---|---|---|---|---|---|---|---|---|---|
| Week 1 | 167k | 167k | $0.84 | $8.43 | $21 | $42 | $84 | $211 | $422 |
| Week 2 | 334k | 334k | $1.68 | $17 | $42 | $84 | $168 | $420 | $840 |
| Week 3 | 501k | 501k | $2.51 | $25 | $63 | $126 | $251 | $629 | $1,257 |
| Week 4 | 668k | 668k | $3.35 | $33 | $84 | $167 | $335 | $837 | $1,675 |
| Week 5 | 835k | The wall is here. 835,000 tokens already fills 84% of the largest context window any model offers, and week 6 crosses 1M outright. Start again and lose the project's memory, or compress it and lose the detail. | |||||||
After using the .dai format: the same weeks, and a good way past them
| Week | History | Read per Q | Convert cumulative | Per Q | T@10 Q | T@25 Q | T@50 Q | T@100 Q | T@250 Q | T@500 Q |
|---|---|---|---|---|---|---|---|---|---|---|
| Week 1 | 167k | 8.7k | $0.15 | $0.053 | $0.68 | $1.46 | $2.78 | $5.40 | $13 | $26 |
| Week 2 | 334k | 10k | $0.31 | $0.060 | $0.91 | $1.80 | $3.30 | $6.29 | $15 | $30 |
| Week 3 | 501k | 12k | $0.46 | $0.067 | $1.13 | $2.14 | $3.81 | $7.17 | $17 | $34 |
| Week 4 | 668k | 13k | $0.61 | $0.074 | $1.35 | $2.47 | $4.33 | $8.05 | $19 | $38 |
| Week 5 | 835k | 15k | $0.76 | $0.082 | $1.58 | $2.80 | $4.84 | $8.92 | $21 | $42 |
| Week 6 | 1M | 16k | $0.92 | $0.089 | $1.81 | $3.14 | $5.36 | $9.80 | $23 | $45 |
| Week 12 | 2M | 25k | $1.83 | $0.132 | $3.15 | $5.14 | $8.45 | $15 | $35 | $68 |
Q = questions asked. T = total: the questions plus every conversion done up to that week. The convert column is cumulative, not a one-off fee: new material is converted as it arrives, week after week. It stays small because each token is converted exactly once and never again, priced at the once-per-conversation rhythm the product actually uses. Read per Q comes from the recall curve published on the savings page, which is measured directly on the v4.4n engine at 22k, 101k, 200k, 502k and 802k-token histories. Rows between those points are straight-line interpolations between two measurements; anything past 802k extends the last measured segment and is an extrapolation. The table stops at week 12 for that reason. We keep the distinction visible rather than turning any of it into a headline cost multiple.
So how often does it convert in practice?
Not per question, and not in one giant batch at the end. Once per conversation, when that conversation finishes. In daidocs-mcp a session-end hook does it automatically, so there is nothing to remember; through the API it is one call when you close a thread. Everything after that is free to ask: recall reads the store and spends no model tokens at all, so a conversation you converted last March costs the same to query today as it did the day it was written.
A finished conversation turned out to be the right unit for three separate reasons, and one of them is a figure we published the wrong way round for months.
You never pay twice
Each token is converted exactly once and never re-converted, whether you convert weekly, daily or per conversation. When you convert does not change what you owe, and re-indexing on a new engine release reuses the conversion you already paid for. Only batch size moves the bill.
Bigger batches are cheaper
We used to claim the opposite: that four small pieces beat one block by 33%. Re-measured on the observer that produces our published numbers, one document costs half what the same text costs split four ways.
A thread is one thought
Converting mid-thread cuts a discussion in half and extracts worse facts from both halves: a decision loses the reasoning that led to it, and a correction loses what it corrected. Waiting for the end costs nothing and keeps the meaning intact.
| Same 20,000 tokens, converted | Observer read | Observer wrote | Cost |
|---|---|---|---|
| As one document recommended | 12,824 | 1,258 | $0.0071 |
| As four documents of about 5,000 | 24,176 | 2,946 | $0.0144 |
| Difference | +88% | +134% | 2.0× more |
Measured on GPT-4.1-mini, the observer behind every published number, over two slices of the same source within eight tokens of each other. The cause is structural rather than incidental: the observer's read is capped per document, so four documents pay four caps, and each one writes its own header, Understanding block, facts and events. The old 33% figure was taken on a small Claude observer we do not recommend converting with, and the ratio did not survive the change of observer. We would rather correct a number in public than leave a convenient one standing.
This is also the configuration behind the published accuracy: the benchmark ingests one complete session at a time, which is exactly what the session-end hook does. The advice and the measurement are the same setup.
What that actually means
Pasting runs out of room in week 6. By week 5 the history is 835,000 tokens (84% of the largest window any model offers), and week 6 crosses a million outright. Through .dai those same weeks are a prompt of about forty thousand tokens, so the ceiling that ends the first way of working is nowhere near the second. That is not a discount on the old way of working. It is a different length of project.
The bill stops tracking the history. Pasting costs more every week because the prompt is the whole history. It doubles when the history doubles. Recall does not: on the fitted curve the prompt grows by roughly three and a half thousand tokens for every hundred thousand tokens of history added.
And the answers get better, not worse. This is the part that surprises people. On the official 500-question memory benchmark, GPT-4o reading .dai files scores 83.00%. The same model with the whole history pasted into its context scores 60.60%. Twenty-two points better, on a far smaller prompt, because a model given the ten thousand tokens that matter outperforms the same model drowning in the whole history. Opus 5, the model priced in the tables above, reads the same store at 91.00%, second only to Fable 5 and inside a standard error of it.
Cheaper, longer, and more accurate are usually a trade-off. Here they are the same decision, and that is the whole argument for the format.
Conversion itself is small and linear: about $0.0009 per 1,000 tokens with GPT-4.1-mini and about $0.0129 with Claude Opus 5, which extracts to a comparable standard for roughly fourteen times the price. Each token is converted once and never re-converted; questions afterwards touch only the store, and recall spends no model tokens at all. Note which price these tables use: they price the self-hosted / bring-your-own-key path at raw model cost. On a hosted plan you pay the 4× metered rate at the top of this page ($0.0036 per 1,000 tokens), so the convert column costs four times what it says, and the retrieval saving is unchanged either way.
Which converter should you pay for?
Converting 500,000 tokens costs $0.46 with GPT-4.1-mini and $6.43 with Opus 5, fourteen times more. Every accuracy number, including the 83.00 that GPT-4o scored and the 91.00 that Opus itself scored, was produced with GPT-4.1-mini doing the extraction. Opus 5 as the observer is a reasonable choice and we would recommend it where you already have it, but we expect it to match GPT-4.1-mini rather than beat it, so we will not sell you one on the promise of a gain.
The floor is what matters. Going below GPT-4.1-mini is the choice that costs you. Sonnet 5 converts, and we would expect it below both of the above. Haiku 4.5 and small local models are where it stops being a saving: extraction comes back thinner or malformed, and the observer's output is not a nicety at the edge of the file, it is the summary, the # Understanding block and the facts, events and profile indexes, which is precisely what retrieval ranks on. Get the extraction wrong and recall returns the wrong files, so the answering model never sees the evidence and the accuracy loss shows up at the end of the pipeline rather than at the conversion step where it happened. Your originals are never at risk either way: # Content and _raw/ are byte-exact whatever converts them, so a better observer later re-reads everything you already have.
Spend your attention on the model that answers too: that is where the measured 14.0-point spread lives (78.00 with Claude Haiku 4.5 answering over all 500 rows, 92.00 with Fable 5 answering, 460/500; same files, same conversion cost). The ordering of the Claude actors tracks capability tier: Fable 5 and Opus 5 at the top, tied inside a standard error of each other, then Sonnet 5, with Haiku 4.5 both the cheapest and the weakest. Answering with Opus 5 scores 91.00% against the 83.00% we publish, so the recommended pairing, convert with GPT-4.1-mini or Opus 5 and answer with Opus 5, sits above the headline benchmark figure rather than at it.
Stated plainly: we have not run a full observer-comparison benchmark. What we know is that the cheapest of the strong observers produces the published results, and that the ranking in the paragraphs above is mechanism and experience rather than a measurement. When the comparison runs, it will appear on the results page before it appears in a price.
Pricing FAQ
Is the free product the paid engine, crippled?
No. There is one engine, v4.4n, Apache 2.0, and it is the one the current headline number was measured on (83.00 with GPT-4o answering). What paid adds is the running of it: it updates itself, re-indexes itself, includes indexing tokens, and never asks you for an API key. Free is the complete local product, not a trial.
What does keyless indexing do with my data?
The relay exists so people without API keys can start in 90 seconds. It forwards your save to the model provider and keeps nothing: the code is open source and the deployment is auditable. Using your own key or your Claude subscription remains the default, and those paths never touch our servers.
What happens if I cancel Starter or Pro?
Canceling stops hosted conversion and auto-updates. Your files, your memory, and the complete local product keep working forever. Re-subscribe anytime, at whatever the list price is that day. Leaving is a supported workflow, not a hostage negotiation.
Where did Personal Cloud go?
It is not a separate plan. The hosted Personal Cloud connector arrives as a free upgrade to Starter and Pro when it ships, at the prices in the grid above. Bulk history import is the one-time Total Recall importer, and metered keyless indexing is covered by credit packs.
Why is self-hosting really unlimited?
Because it costs us nothing to run. Self-hosted, your memory is files on your disk, retrieval is code on your machine, and recall is answered by the Claude plan you already pay for. So there is no meter, forever. The hosted Free tier is a different thing: it is metered at 3 conversions, because those run on our machines and our model spend.
Is my memory used for training?
No. On free, your data never leaves your machine unless you point a key at an indexer you chose. Keyless saves pass through the zero-retention relay and are kept by no one. The product is the folder, not your data.
Create a free Kerneta ID
Optional, and never required for local use. A free ID gets you 300 keyless starter saves (no API key setup, working memory in 90 seconds), release alerts with one-click retroactive re-index, your receipts and licenses in one place, and a Cloud waitlist position with a 72-hour founding window before public sale.
We write at most monthly: benchmark drops, release notes, ecosystem news. Analytics and advertising tags run only if you agree to them.