Developer documentation

Revo's memory engine reads the text your work produces, keeps the facts drawn from it current, and records where each one came from. Two interfaces read that memory: the MCP Server and the Memory API.

What it is

Send us any text: an email, a call transcript, a support thread, a note. We read it, work out who and what it is about, and keep the result current. Then you ask a question in plain language and get an answer back with the evidence it came from.

There is one input: text, plus a timestamp. You do not have to define a schema, build an index, pick an embedding model, or chunk anything.

MCP Server or Memory API

Both run on the same engine. They differ in how you integrate and who the memory belongs to. The MCP Server connects an AI assistant that already exists to a Revo workspace, one user at a time. The Memory API puts memory inside software you are building for a workspace you control.

From text to answer

What follows is the shape of the pipeline, simplified for clarity: five stages that every piece of text goes through, whether it is an email, a transcript or a PDF. The API lets you intervene at several points along it. POST /ingest runs the first three, GET /ingest/{id} reports when they are done, POST /recall stops at stage 4, and POST /answer goes on to stage 5.

1. 1CaptureThe original text is kept word for word, with its timestamp.
2. 2UnderstandWho and what it is about. People, companies and projects are each resolved to one node.
3. 3DistillFacts worth keeping are maintained: a new value replaces the old one, and the earlier value stays in the history.
4. 4RecallA question pulls everything relevant, ranked, and filtered to what the asker may see.
5. 5AnswerGrounded in the retrieved evidence only, and returned with that evidence attached.

What it looks like once it is built

The result is a knowledge graph: resolved entity nodes carrying a type, and typed relationships between them that carry dates. The types are a default rather than a fixed set, so a custom ontology can be defined for your workspace if your domain needs one. Every node keeps three layers, which is what the panel below shows: the verbatim mentions it was built from, the dated observations drawn out of them, and the value that holds now, with superseded values kept in the history.

Compared to plain search

Plain search returns snippets that mention the words you typed, and you work out the answer from them.

Take the renewal above. It was discussed at $42k in May, then agreed at $48k in July. Search returns both numbers with no indication of which is current. We keep one current value, $48k, and keep the May figure in its history. Ask what the renewal is worth and you get $48k, the fact that it went up, and links to both sources.

• Answers are current. A new fact replaces the old one rather than sitting beside it. Where sources genuinely disagree, both stay visible and both are dated.
• Answers include their sources. Every response returns the exact lines it read and where they came from. If the memory does not hold the answer, it says so.
• It updates as content arrives. Every new email or call adds to it, with no maintenance step.

Privacy and permissions

Permissions are enforced inside the engine. Every piece of content has an audience, and retrieval is filtered to what the asker is allowed to see while it runs rather than on the results afterwards, so content the asker may not see is never loaded on the way out.

• One tenant cannot reach another.The workspace is resolved from your key on the server. It is not a parameter you can pass, so nothing in a prompt can redirect a call to someone else's data.
• Your data is not used to train models. It is stored to answer your questions and nothing else.
• Deletion removes what was derived. Delete a source and the facts drawn from it go too, along with the sentences that produced them.
• The platform is certified. SOC 2 Type II, ISO 27001 and ISO 27701. The API runs inside that same scope.

One limit worth knowing now: the audience filtering above is enforced by the engine, but /ingest does not yet take an audience, so everything you push in through the API lands with the workspace as its audience. Scoping a data point to particular end users of yours is the next milestone on the Memory API roadmap. Tell us if you need it before it ships.

Cost

The usual alternative is to send the whole history to the model on every question, so the bill grows with the history. We read a roughly fixed amount per question whether the record holds a hundred thousand tokens or ten million.

Every call also returns what it cost under usage, so you can price a feature or cap a user without instrumenting anything.

How we measure it

We test on BEAM, a public benchmark from ICLR 2026. It hides answers inside conversations of up to ten million tokens, asks questions about them, and grades ten separate skills. The paper and the dataset are both public.

We report two numbers per skill, because they answer different questions:

• Was the answer in what we retrieved? If it is not, nothing downstream can fix it. It is the bar in the chart.
• Did a model then get the answer right from it? That depends on which model reads the evidence, not on us. It is the line in the chart.

On the same questions and the same judge, against Hindsight's published retrieved contexts, we retrieve the answer 93.3% of the time against their 75.8%, and we lead on eight abilities of ten. Hindsight is the only vendor here whose harness and judge are public, which is what makes a direct comparison possible.

For context on the field, Exabase reports 76.9% at 100k, 75.0% at 1M and 68.0% at 10M on the end-to-end score, and Hindsight reports 64.1% at 10M. Those are answer scores rather than retrieval scores, so they are not the same measure as our bars above. Compare them with care: every published number in this field is graded by the vendor who published it.

Full benchmark coming soon. We are finishing repeated runs at 1M and 10M tokens, and we will publish every ability, the judge and the harness, next to a direct comparison with Hindsight and Exabase. Ask us for the current numbers before then.

We publish all ten abilities, including the one we score worst on, plus the judge and the harness, so anyone can re-run the benchmark.

Get access

The Memory API is in early access with a small group of design partners. Book a call and tell us what you are building.