How is Reasera Memory different from RAG?

In Reasera's own evaluation: standard RAG retrieves documents and then lets a language model say anything that sounds fluent. Reasera Memory answers from memory itself, with no language model writing the answer: it attaches a certainty level and a receipt, and declines with a reason when the evidence is not there. On 3,903 held-out questions with the same documents on both sides, Reasera was right 98% of the time at the certain level, which covered a third of the questions, versus 33% for standard RAG with an 8-billion-parameter model, even though retrieval found the right document 98% of the time.

What happens when the information is not in the documents?

In Reasera's own evaluation: Reasera Memory declines and says why: no source, insufficient evidence, conflicting sources, or retracted. On 176 questions where the subject's record was in memory but did not contain the answer, Reasera declined 97% at the certain level. Standard RAG, as normally configured, does not decline and answered all 176 from the model's own recollection, 20% of them wrongly; the same model, told it could say unknown, still answered 168. On 1,000 questions asked against the wrong record, Reasera gave no certain answer.

Does a correction stick if the same claim comes back in different words?

Yes, in Reasera's own evaluation. Retraction applies to the claim wherever it appears, so reworded copies present and future are refused while unrelated facts keep serving. In 6,334 trials where a withdrawn claim was re-added in different words, Reasera served it again 0 times, with no unrelated fact blocked; standard RAG, which deleted the document instead, served it again 64% of the time, so only 36% of its corrections stuck.

Why not delete the document in a RAG system?

Deleting removes one document, but a wrong claim lives in many documents and new copies keep arriving in tickets, transcripts, and re-crawls. Retraction in Reasera is a standing instruction: the claim is withdrawn in whatever words it appears, now and later, and the record of what was claimed, when it was withdrawn, and by whom is kept.

Reasera Memory

A model with lifelong memory.

Q: How does Reasera Memory integrate with AI agents?

Reasera Memory is an HTTP API and an MCP server. Applications add sources, teach facts, ask questions, check for certified absence, and read the gap list from any programming language; agents and copilots connect through MCP and receive the same certainty levels and receipts. API keys carry memory-specific scopes, and retract, supersede, and redact require a signed-in person.

Remembers what you tell it, for as long as you want.
Says “I don’t know” instead of guessing.
Every answer comes with a receipt: the source, the line, the date.
Tell it once it was wrong. It never says it again.
Tell it to forget, and it is gone everywhere.

Give agents and assistants a model that holds what your organization knows, answers only from it with the evidence attached, and learns from every fact and correction you give it, with no retraining.

Request a demo See the API →

What every answer comes with

A certainty level, a receipt, or a reason.

Certainty level

certain · certified: this kind of fact has earned it in your memory.→ Safe to show.

likely · supported by the source, below the certified level.→ Show with a caveat.

possible · supported by the source, with less evidence.→ Verify before showing.

attested · the source states it; this kind of fact has no certainty level here yet.→ Quote it, or verify.

gap · no answer, with a reason why.→ Route it, or ask a person.

Levels come from your own records and corrections. Your application sets the bar for each use: what to show, what to caveat, what to escalate.

Receipt

source · which document or stream the answer came from.

passage · the exact span that supports it.

added · when it entered memory, and by which event.

Receipts make answers checkable by people and auditable after the fact.

Reason for a gap

no source · nothing in memory covers this.→ Add a source.

insufficient evidence · something is there, but not enough to certify.→ Add corroboration, or verify by hand.

conflicting sources · your sources disagree.→ Resolve it: supersede or retract one.

retracted · this claim was withdrawn by your team.→ No action needed.

Certified absence

“No record” is a checkable answer.

A vector store cannot tell you something is not there. A low similarity score is a guess. Reasera keeps a complete index of everything in memory, so absence is a checkable certificate. Your agent can say “we have nothing on this” and mean it.A certificate says that nothing in memory covers this. It does not say that nothing exists anywhere. Because the index is complete rather than a similarity search, a record filed under that subject is always found. If the record is there under a different name, the result is a gap with a reason, never an invented answer, and it lands on the gap list so a person can connect the two.

97%

declined when the subject’s record was in memory but did not contain the answer (170 of 176). Standard RAG, as normally configured, does not decline: it answered all 176, 20% of them wrongly.

Measured on our evaluation sets · How we measure

Retraction that survives rewording

Retract a claim once. In 6,334 trials, none came back.

Retraction applies to the claim wherever it appears, in any document. Delete a document from a vector store and a paraphrased copy will serve the same wrong claim again tomorrow. Retract it in Reasera and reworded copies are refused as well, including copies that arrive later, while unrelated facts keep serving. When the answer has simply changed, supersede it with the new one and the old answer stops serving.

100%

of withdrawn claims stayed withdrawn after the same claim came back in different words (6,334 of 6,334 trials). Standard RAG, which deleted the document instead: 36%.

Measured on our evaluation sets · How we measure

Why not delete the document?

We did, on the RAG side, and the claim came back anyway. Deleting removes a document; a wrong claim lives in many documents, and new copies keep arriving in tickets, transcripts, and re-crawls. Retraction is a standing instruction: this claim is withdrawn, in whatever words it appears, now and later. And unlike deletion, it keeps the record of what was claimed, when it was withdrawn, and by whom.

Erasure that is real

When content must not exist, it doesn’t.

Retraction says the claim is wrong: the content stays for the record, and memory refuses to serve it. Redaction says the content must not exist: it leaves the ledger and every cached copy, and the store is rebuilt without it. Both actions require a person with the right role. API keys cannot perform them.

Redaction removes

✓ the source text
✓ its span in the store
✓ every cached copy

What remains

• the event: who, when, which record
• a one-way fingerprint for the audit trail

Gaps are a to-do list

Every decline points at the missing source.

Each gap is recorded with its subject and reason, surfaced on your dashboard, and pushed to a webhook the first time it is seen. Your content team gets a ranked list of exactly what memory is being asked and cannot yet certify. It is the shortest list of what to add next.

Memory gaps · this week

Q3 price list	no source	14×
Northgate SLA credits	conflicting sources	6×
EU data residency	insufficient evidence	3×

Measured

The usual alternatives, on the same questions.

Both sides get the same documents and the same questions. On one side, standard RAG: dense retrieval feeding an 8-billion-parameter language model that generates freely. On the other, Reasera Memory, which answers from memory itself. Retrieval handed RAG the right document almost every time; the difference is what happens next.

When it answers, how often is it right?

Questions a small language model cannot answer on its own, with the answer present in the record. Reasera gives 34% of them a certain answer, another 29% a likely or possible answer (right 89% of the time), and marks the rest attested: stated by the source, no certainty level yet. Standard RAG answers every question. (3,903 questions)

Reasera Memory (certain)98%

Standard RAG (8B model)33%

Does a correction stick?

Withdrawn claims that stayed withdrawn after the same claim came back in different words and the question was asked again. Reasera retracted the claim; RAG deleted the document instead. Unrelated facts blocked: 0 of 19,002 checks. (3,167 claims, two rewordings each)

Reasera Memory100%

Standard RAG36%

Does it admit when it has nothing?

Questions where the subject’s record was in memory but did not contain the answer. Reasera declined 170 of 176 at the certain level. RAG, as normally configured, does not decline: it answered all 176 from the model’s own recollection, which is unverifiable and was wrong 20% of the time. Told it could say “unknown”, the same model still answered 168. (176 questions)

Reasera Memory (declined)97%

8B model, allowed to decline5%

Standard RAG (declined)0%

Evaluation sets drawn from all 21,919 CounterFact records, one per subject, with Wikipedia summaries as the records. Memory holds 9,792 of them; the 3,903 held-out questions are the ones scored. 176 questions whose record lacks the answer; 1,000 asked against the wrong record, on which Reasera gave 0 certain answers; 3,167 retractions with two rewordings each, 6,334 trials. Reasera’s answers come from memory itself: no language model writes them. Standard RAG = dense embedding retrieval, top document from a 10,650-document pool, Llama 3.1 8B Instruct generating freely; retrieval found the right document 98% of the time; the same word-level scoring rule for every arm. The 8B model alone, without the document, gets 23%. Scored against the dataset’s single answer; counting an answer as right when that answer is a member of the form it was served in (a list, an alternative, or a nesting such as city, state, country), the certain level is right 98.5% of the time and standard RAG 34%. The 29 certain-level misses are kept with the results and reviewed by hand. A fixed sample of these sets gates every release.

Results are from Reasera’s fixed evaluation sets, described above, and are re-measured before each release. Performance on your data depends on your sources, configuration, and questions, and is not guaranteed.

How we measure. Questions come from CounterFact, a public dataset of facts, with each subject’s Wikipedia summary as the record. Memory is loaded with the records the way a customer’s store is, and scored on held-out questions it has never seen; retraction trials re-add a served fact in the dataset’s own rewordings. Both sides get the same documents and the same scoring rule; Reasera’s headline figures count only answers given at the certain level, and every certain-level miss is kept with the results and reviewed by hand.

Integration

An afternoon, not a migration.

Memory is an HTTP API and an MCP server. Add sources, ask questions, check for absence, and read the gap list from any programming language. Agents and copilots connect through MCP, the standard tool interface for agents, and get the same receipts.

POST /ingest: add a document, transcript, or record
POST /facts: teach a fact: a question, its answer, and the source that states it
POST /recall: ask; get a certainty level, a value with its receipt, or a reason
GET /absence: certify that memory holds nothing on a subject
GET /gaps: what memory is being asked and cannot certify
retract · supersede · redact: curation, people only

API keys carry memory-specific scopes that generic read/write keys do not imply. Curation actions are never available to keys. Webhook: memory.gap_detected.

Questions are phrased as statements to complete. Memory finds the source from the question and names it in the response; pass a subject to ask about a specific source. The example shows the real request and response shapes.

POST /api/app/memory/recall
{
  "prompt": "The refund window for annual plans is"
}

200 OK
{
  "tier":     "certain",
  "subject":  "policies/billing-2026.md",   // found from the question
  "resolved": true,
  "form":     "single",
  "values": [{
    "text":  "30 days",
    "type":  "number",                       // a coarse label, for routing and display
    "tier":  "certain",
    "source": {
      "source_key":  "policies/billing-2026.md",
      "evidence":    "Annual plans may be refunded within 30 days of purchase.",
      "span":        [1204, 1257],           // where in the store
      "event_id":    "8f2c…",
      "ingested_at": "2026-08-14T09:12:07Z"
    }
  }]
}

// or, when the evidence isn't there:

{
  "tier":   "gap",
  "gap":    "no_source",
  "values": []
}

Built for regulated operations

Enforced by the system.

Private to each customer

Each customer has its own memory. Nothing in it is shared. Client accounts are separated within it.

The ledger is the truth

Every addition, retraction, supersession, and erasure is an event. Replaying the ledger rebuilds a customer’s memory exactly. Cached state is only a cache, encrypted with a key unique to that customer.

Curation is a human act

Retract, supersede, and redact require a signed-in person with the right role. A leaked API key cannot erase or rewrite what your organization knows.

Your data stays yours

Everything your memory learns, it learns from your own documents, corrections, and retractions. None of it trains a shared model, and a gap in your memory is never filled from someone else’s.

Continual learning, by design

Memory that keeps learning.

Reasera Memory grew out of years of research into language models that learn continually: from each event as it arrives, keeping provenance, and without trading exactness for fluency. Inside the Reasera platform it holds what your organization knows and proves it, while classifiers and a re-ranker learn from your team’s corrections as they work. A gap in memory can be routed to the right model, tool, or person, and the routing itself keeps learning. The memory mechanism is patent pending.

More continual-learning models are coming from the same research, each held to the same evidence gates. See the platform →

Watch it decline a question it shouldn’t answer.

Live, on your documents. A 30-minute walkthrough with the founder.

Request a demo →