Free forever. Paid buys hands, not head-starts.

What paying actually buys

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.

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.

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

After using the .dai format: the same weeks, and a good way past them

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:

Put together, the advice is simple: convert whole conversations when they finish. How often you convert never changes the bill; only how much you convert in one go does, and the table below shows by how much.

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.

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.

Create a free Kerneta account