Questions we get asked about the design

Why this design

Isn't this just RAG with extra steps?

Not quite, and the difference is specific.

Similarity search returns text that resembles your question. A correction rarely resembles the thing it corrects — it's shorter, worded differently, often a footnote on a later document. So the agreeing text outranks the disagreeing text, and a model reading only the top results never learns there was a disagreement. It doesn't fail at reasoning; the counter-evidence never arrived.

Tortoise keeps the source text and additionally records the one thing the text cannot contain: the relationships between pieces, as typed constraints. “These two conflict.” “This replaced that.” Belief is then computed over those constraints — conflicts and support carry a weight and propagate, replacement is tracked structurally — rather than over text similarity, which is what makes Tortoise a cognitive layer for agents: reasoning, memory and learning, rather than a better index. The mechanism itself — what each relation does to a score — is on the docs page.

Why not let the model work out contradictions at query time?

It can only judge what is in front of it. Deciding whether A contradicts B requires having both, and contradictions are the least likely pair to be retrieved together.

That is circular: you need to know the relationships to retrieve the right material, and you need the right material to discover the relationships. Recording a relationship when it is observable is what breaks the circle.

The model still makes every judgment call — what a conflict means, how much weight it deserves, and whether it matters for the question being asked. What it doesn't have to do is remember, on its own, that the conflict exists.

Do you replace my source text with extracted facts?

No, and this is the one we would most want you to hold us to. Your source stays authoritative: extraction is additive. It builds a revisable index beside the stored evidence — every extracted claim carries the source it was drawn from — and does not rewrite what extraction read, so a correction in the extraction changes the index, not the record. The stored turn is shaped once, on the way in: a captured turn longer than 5,000 characters is cut at that window, and any cut that discards readable text is marked with a truncation marker naming the turn's original length — while credential-shaped spans are redacted — both applied before the write, not after it.

An external study — Fidelity Before Structure: Verbatim Chunks Beat Lossy Artifact Extraction in Long-Conversation LLM Memory (Tao An, arXiv 2601.00821) — held the retriever, reranker, answerer and judge fixed and swapped only the stored representation: verbatim source won by 15.9 points on LoCoMo and 22.0 points on LongMemEval-S, and a one-hop semantic graph did not close the gap. The authors read the result as lossy distillation rather than structure as such: accuracy tracks how much source text survives in the store.

That study measured one-hop semantic graphs — a store of relationships you look up; Tortoise is not one. It computes over typed relations — IMPL and NAND constraints, each carrying a weight — propagating belief across them with expectation propagation, so a contradiction changes a score rather than sitting in a table. The study is the case for keeping the source text rather than only extracted artifacts, and Tortoise keeps both layers: the captured source underneath, and the reasoning layer over it.

What happens when the graph is wrong?

You correct it, and belief recomputes. Nothing is frozen.

• You can supersede a claim — the old one is retained and linked to its replacement rather than deleted, so “what did we believe in March” stays answerable.
• You can retract a claim without replacing it.
• You can contradict a claim, which lowers the belief in it without erasing the record of the disagreement.

If you disagree with a confidence score, you don't argue with the system. You add evidence, and it moves.

Does a contradiction delete the losing belief?

No. Both claims stay in the graph, with the tension recorded. That is the point of keeping a contradiction as a first-class relationship instead of overwriting one side.

A deleted belief leaves no trace of the disagreement, so a later reader sees a confident answer with no idea it was ever contested. A recorded contradiction stays visible, and keeps pulling on the confidence of the claims it connects — on both sides for a mutual contradiction, on the target only for a directed one — until it is genuinely resolved or superseded.

Is a graph slower than vector search?

Two different costs, and it depends on how often you read.

The expensive part of Tortoise is at write time: reading and judging incoming material to extract the relationships. That cost is linear in how much you ingest, and it does not get cheaper per item as you grow.

The read path is the opposite trade. Because the relationships are already recorded, working out a claim's belief needs only its neighbourhood, and the lookup itself is index-backed rather than a scan of the corpus. Retrieval runs in parallel across full-text, vector and structural strategies, and on the SDK with hop expansion enabled, can expand from the retrieved hits to the neighbourhood around them.

So: pay once at write, or re-derive on every read. Which is cheaper depends on how many questions you ask of the same material. Ingest a lot and ask twice, and the precomputation isn't worth it.

How does it scale?

Belief propagation is bounded by design:

• Adding a claim costs work proportional to how many things it connects to — not to the size of the store. Unrelated claims don't interact.
• Belief is computed over a bounded neighbourhood around each claim, capped by default at a small number of hops (one for an anchored confidence read, two on the propagation path), and a dirty-root pass expands the exact affected closure instead of the whole graph — which is what keeps the common read local. Operator selection is capped too, truncated deterministically by id, and the result reports it (truncated), so a capped pass is visible rather than silent.
• Concurrent writers run on the Docker path — integration-tested to 5 writers — and on the hosted service, which is the deployment built for teams.

How belief works

Is a confidence score a fixed verdict, or does it move?

It moves. Confidence is derived: every claim's score is recomputed from the evidence attached to it, and the stored number is a cache of that computation rather than a ruling.

Add support from a stronger source and it rises toward that source's level. Add a contradiction and it falls. Supersede the evidence it rested on and it recomputes without it. Nothing is stamped at write time and frozen.

What does the variance on a confidence score mean?

A confidence score is a distribution, not a single number — so it carries a spread as well as a centre.

A tight spread means the evidence has settled. A wide spread means it has not: either there is very little evidence, or the evidence points both ways. That distinction is why a claim can be flagged as contested rather than handing you a middling score and leaving you to guess which situation you are in.

Contested claims are often the interesting ones. A 0.5 that nobody disputes and a 0.5 that two strong sources are fighting over are different situations, and only one of them deserves your attention. The full treatment is on the docs page.

What is expectation propagation?

It is how the belief score is actually computed, and the reason a score can change after the claim was written. Support and contradiction propagate along the relationships connecting a claim, and its score settles at whatever the surrounding evidence supports.

Unlike a system that assigns each claim a number once, the score here is a distribution that is updated as evidence accumulates around it.

It also means a contradiction is a first-class force rather than a missing record. Silently replacing a contradicted claim looks identical to never having recorded the contradiction — until you need to know why the belief changed. For the mechanism itself, the docs page has the full account.

What happens if extraction misses something?

If a relationship is missed when it is observable, no later search recovers it, because the relationship was never inside either document — which is why extraction quality is what the write path spends its effort on, and why the captured source text is kept as the authoritative record.

The graph sits over the evidence; it does not replace it. A missed relationship leaves the graph incomplete — the underlying record is untouched, and the stored text is still there to search directly, within the capture window: a turn over 5,000 characters is cut at that window, and a cut that discards readable text carries a truncation marker naming the turn's original length.

How is this different from other memory systems?

One specific thing: propagated confidence — a belief score that moves when the evidence around it moves, rather than a static field written once. A graph stores relationships; Tortoise computes over them, propagating belief across the weighted ones so a claim's score reflects the evidence that actually bears on it.

Across the systems we have surveyed: most have some form of graph, two have partial contradiction handling, one has a formal revision theory, and no surveyed agent-memory product propagates credence — Tortoise is the one that pairs typed implication with propagated confidence, the combination no surveyed product ships.

We keep a mechanism-named comparison in the public repo — what each system actually does, not what it claims — where every Tortoise row that carries a number is drawn from a run of ours, every vendor row is labelled as a vendor or third-party measurement, and anything of ours we have not run is marked PENDING, or recorded as not adopted, with no number. The capability survey behind those counts is product/competition/_analysis.md; the benchmark-by-benchmark numbers are in docs/benchmarks/comparison-systems.md.

Using Tortoise

What does it cost?

Pricing is stated on the product page — metered write operations, with reads free at every tier. Self-hosting is also a real option if you would rather run it yourself than pay per write (see self-hosted): the source is public and the licence is source-available rather than open source, with production use free for organisations at or below the $5M revenue threshold.

We are not going to restate a price here, because a copy of a price is exactly the kind of thing that goes stale without anyone noticing. The product page is the single place it is stated.

Can I export my graph, and what if I stop using it?

Yes, on both paths. Self-hosted, the CLI writes a versioned encrypted export artifact (tortoise export), and the graph lives in your own database anyway. On the hosted service, a team owner can export the graph — every point with its properties, every relationship, and entity nodes, plus the recent event log (the newest 5,000 events within the 30-day window) — as JSON; it is owner-only, rate-limited and audit-logged.

What happens to your data after you stop using the service — retention, deletion, termination — is governed by the Terms of Service and the DPA. Those documents govern that question; this page does not, and will not attempt to.

Who can read my data?

Only authorised personnel operating the service can reach production systems, and access to personal data is limited to what is necessary to operate and support the service — stated in full in the privacy policy, with the contractual terms in the DPA.

The technical controls behind that — encryption in transit and at rest, how API key credentials are stored, what control-plane activity is logged — are on the security page.

We do not restate those documents here, because a summary is precisely the artefact that drifts out of sync with what it summarises.