# How it works.

Renor gives AI tools and agents durable memory so they recall context without repeated manual prompting. This page says what is stored, how it changes, how it is read back and what is not built yet.

## The three-step cycle.

Designed to run silently beneath your primary development and reasoning tools.

01

### Connect

Add one MCP address to the AI tools or agents you use and sign in once.

02

### Remember

Your agent saves what should last: a fact, a decision or a note. Nothing is saved unless an agent or you asks for it.

03

### Recall

Before it works, your agent asks Renor for context and gets the current facts and the closest notes.

## What is stored, and how it works.

Every claim below is read off the code or a measurement record we keep; each section names its source. The engine's source is public at https://github.com/renorai/renor-engine; the evaluation ledger, gateway and private tooling are not, so some named files are not public.

Architecture Stored Writing Corrections Forgetting Recall Agents Export Availability Tools Speed Not built FAQ

## Architecture

Agents reach Renor through one MCP address. A gateway checks who you are and passes the call to the process that serves your workspace. That process keeps two things: a Markdown store, which is the memory, and a SQLite index derived from it for search.

The Markdown store is the memory; the index is a copy that can be deleted and rebuilt.

Facts that change are kept as subject, predicate and value; the newest value answers and the earlier ones stay as history. The worked example is under “How a new value replaces an old one”.

## What a memory is, and where it lives

A **fact** is a subject, a predicate and a value (`Fjord`, `database`, `SQLite`), saved together with the sentence you said. A **note** is your words, kept whole in a Markdown file under the day it was saved. Facts go to an append-only ledger, one Markdown file per workspace; notes go to daily files.

The ledger and the notes are the memory. The search index (SQLite: chunks, a keyword index, entities and the embedding vectors) is a copy derived from them, and can be rebuilt by replaying the ledger. Each workspace has its own memory directory, its own index and its own server process, on Renor’s infrastructure. Where that infrastructure is, and what it runs on, is on [Security and your data](https://renor.cloud/security).

Source: engine/docs/adr/0001-ledger-first-memory.md; engine/docs/user/WHAT-YOU-CAN-DO.md.

## How an agent writes a memory

- `remember` takes a `statement` in plain words, up to 4,000 characters. A longer one is refused, never cut. Without anything else it is saved as a note and searchable at once.
- With `subject`, `predicate` and `object` as well, the statement is saved as a fact. Use this only for a value that stays current until it changes: a city, a project’s database, a deadline.
- `save_memory` is the fact form alone (no sentence of yours is kept). `remember_note` appends a timestamped line to a day’s log.
- Saving the same statement for the same fact twice changes nothing. A save returns a receipt: `store`, `supersede` or `nochange`, and an event id.
- An optional `scope` such as `project:fjord` keeps a memory with one project.

Source: engine/src/mvp/server.ts (remember, save_memory, remember_note).

## How a new value replaces an old one

The test that matters: on day 1 an agent saves that a project uses PostgreSQL; on day 5 it saves that the project moved to SQLite; on day 10 someone asks which database the project uses. Renor answers SQLite and keeps the PostgreSQL value, with the dates it was current, as history. This is the output of the real tools from a run on 2026-10-07 (the two saves are seconds apart there; in use the dates are the days you saved them):

```
remember   subject Fjord · predicate database · object PostgreSQL
  → action "store"      created  { object: "PostgreSQL", validFrom: "…21:52:30.275Z" }

remember   subject Fjord · predicate database · object SQLite
  → action "supersede"  closed   { object: "PostgreSQL", validTo:   "…21:52:30.967Z" }
                        created  { object: "SQLite",     validFrom: "…21:52:30.967Z" }

get_context("what database does Fjord use?")
  → facts: [ { subject: "Fjord", predicate: "database", object: "SQLite" } ]

retrieve_memory { subject: "Fjord", predicate: "database", include_history: true }
  → { object: "SQLite",     current: true,  validFrom: "…21:52:30.967Z", validTo: null }
    { object: "PostgreSQL", current: false, validFrom: "…21:52:30.275Z", validTo: "…21:52:30.967Z" }
```

The ledger records the change as an event that names the one it closed, so the whole history survives an index rebuild and shows up in an export:

```
## MEM_MUYN8CMZPSI142 · 2026-10-07T21:52:30.967Z
- kind: supersede
- subject: Fjord
- predicate: database
- object: SQLite
- closed_event: MEM_MUYN8C3O7FIQH5
- statement: "We moved Fjord to SQLite because it needs no server."
- source: node
```

`retrieve_memory` with `as_of` and an ISO date returns what was current at that time, so “what did we use on day 3?” answers PostgreSQL.

**What this depends on.** The replacement happens only when the agent saves the new value with the same subject, predicate and scope, spelled the same way. An agent that records “we moved to SQLite” as a plain note leaves the earlier note in place, and Renor does not read the sentence to work out that it contradicts anything. Renor warns when it sees the same predicate under a name one word longer or shorter, or in another scope (`possibleDuplicates`), and changes nothing on its own.

Source: output of engine tools run in a test workspace, 2026-10-07 (no embedding provider, so the reply reports keyword retrieval); engine/src/mvp/server.ts (retrieve_memory); engine/tests/mvp/server.test.ts (correction keeps history across a restart).

## Retire and restore

`retire_memory` takes one memory out of recall without deleting it: a note file moves to a retired area, a log entry moves out of its file, a fact leaves every read, and all of them leave search at once. The ledger keeps who retired it and when. `restore_memory` puts it back exactly as it was and re-indexes it. A wrong fact is corrected by saving the right value, not by retiring. Retiring is reversible by design, so it is not erasure. The owner can then delete a retired note, log entry or fact permanently on the dashboard’s Memories page, which cannot be undone and frees a retired note’s storage; agents cannot. Erasing a retired fact leaves one line in the ledger with none of its words. Account deletion is on [Security and your data](https://renor.cloud/security).

Source: engine/src/mvp/server.ts (retire_memory, restore_memory, delete_retired_memory); engine/src/memorymap/memoryMap.ts (purgeRetired); engine/docs/user/WHAT-YOU-CAN-DO.md.

## How get_context and search choose what to return

- **Facts first.** The current values of the facts that best match, read from the ledger: up to 12 for a query (20 with no query), within the share of the token budget that facts get. Matches beyond that are left out. A fact saved a moment ago is found by exact words before the index has caught up.
- **Then notes, by meaning and by words.** Every hosted workspace has semantic search on, so the reply’s `retrieval` field says `hybrid`: a search by meaning plus a keyword (BM25) search. A workspace without an embedding provider would say `keyword` and match exact words only.
- **Who computes the embeddings:** Google Vertex AI (`gemini-embedding-001`, 768 dimensions). The workspace sends it the text of notes when they are indexed and the query when it searches; there is no embedding model on Renor’s side. The [privacy policy](https://renor.cloud/privacy) lists this transfer.
- **Order and budget.** Matches are listed newest first by default (a question about the past is listed by score). The whole reply fits `max_tokens`: when it does not, keyword matches go first, then the lowest-scoring meaning matches, but the newest relevant match is kept.
- **An honest miss.** If nothing closely matches, the reply says `relevant: false` and the nearest items are labelled as only the nearest.

The memory map and `lookup_entity` link people, projects and topics by tag, wiki-link and literal name mention, for browsing. Answers do not come from a knowledge graph built from your text; the one place retrieval follows links is the `[[wikilinks]]` you wrote between notes: a note linked from a match can be added as a further match (its `reason` is `graph`). The measured effect of these choices is on [Research](https://renor.cloud/research), including the changes that made answers worse.

Source: engine/src/mvp/server.ts (get_context, search_memory); engine/src/mvp/agentMemory.ts (budget); engine/docs/evals/results/CUT-BY-SCORE-20261007.md.

## Several agents, one workspace

A workspace belongs to one owner account. Every MCP client that account signs in (a chat app, a coding agent, a CLI) reads and writes the same memory. What is recorded about who wrote what:

- Each memory carries a `source`: the name of the app or agent that saved it, shown in the dashboard as “by claude-code”. A file path or link is cut down to its last name; a name is kept to 40 characters.
- A named connection's author is **authenticated**; only an unnamed fallback label is self-reported.
- `scope` separates projects inside the workspace (`project:fjord`). It is a folder, not a permission: a read without a scope sees every scope, and there is no per-agent access control.

Sharing one memory between several people is not built (see below).

Source: engine/docs/user/WHAT-YOU-CAN-DO.md (source, scopes, “What does not exist yet”).

## Export and import

`export_memory` returns everything the workspace holds as portable Markdown, in one documented format (`renor-export/v1`): the fact ledger exactly as stored (every fact event with its id, time, kind, subject and predicate, its value or, for a retire or restore, the event it acts on, the sentence you said when you gave one, its source, and its scope when it is not global; superseded values and the event that closed them included), every daily-log entry with its id, time, source and scope, every other note in full with its metadata, and everything retired and not restored, newest first. The reply is a JSON manifest — counts per kind, the sections it carries, where to continue — followed by the document. It is plain text you can copy, back up or read without Renor.

**A large workspace is paged, never cut.** One reply is bounded (600,000 characters by default). Follow `nextSection`: call again with `section` set to it (`ledger`, `daily-entries`, `notes`, `retired`, `learning-log`) and `offset` set to `nextItem` (0 when absent), until `nextSection` is null. An item larger than the bound is returned alone. Not exported: the search index and the embeddings, which are derived from the Markdown and rebuilt from it.

Import goes the other way: `preview_import` shows what would be added (up to 100 Markdown files, 64 KiB each), `apply_import` adds them under `Imported/<label>` without overwriting anything, and `undo_import` retires exactly what that batch created. Imports create notes, not facts.

Source: engine/src/mvp/exportAll.ts (export_memory, format renor-export/v1); engine/src/memory/lifecycle.ts (ledger event fields); engine/src/memorymap/memoryMap.ts (daily entries, retired items); engine/docs/architecture/EXPORT-FORMAT.md; the paging and completeness behaviour is asserted by engine/tests/mvp/export-everything.test.ts.

## When the workspace is asleep or unreachable

Your agent talks to one public gateway, which finds your workspace’s process and passes the call on. An idle workspace stops, and the gateway starts it again on its next call (on-demand sleep is on in production), which takes a few seconds. A brand-new workspace that is not published yet holds the call for up to 25 seconds and then answers it. If the workspace cannot be started right now, the call fails with a 503 and a `Retry-After` header. An unknown workspace gets a 502. In every one of these cases the call fails and **nothing is written**: Renor does not queue a write for later and there is no copy in your agent that syncs afterwards. A write the gateway could not deliver is not replayed, so an agent that wants it saved has to try again. An agent should treat a failed Renor call as “no memory this time”, not as “nothing relevant”.

Source: engine/apps/gateway/README.md; engine/src/mvp/idle.ts.

## The endpoint and the tools

One MCP endpoint, over Streamable HTTP: `https://mcp.renor.cloud/mcp`. You sign in as the owner; a request without a valid token reads and writes nothing. The 24 tools:

- `get_context` — read: current facts first, then the closest notes, within a token budget
- `remember` — write: one statement in plain words, optionally with subject, predicate and object
- `save_memory` — write: a fact as subject, predicate and object only
- `remember_note` — write: append a timestamped line to a day’s log
- `retrieve_memory` — read: the value of one subject, with history or as of a date
- `search_memory` — read: search notes by meaning (only where semantic search is on)
- `search_text` — read: search notes by exact words
- `search_history` — read: search promoted past chat-history notes, where configured
- `lookup_entity` — read: find a person, project or concept by name or alias
- `memory_map` — read: browse everything the workspace holds
- `read_memory` — read: one memory in full, by id
- `retire_memory` — forget: take one memory out of recall, reversibly
- `restore_memory` — put a retired memory back
- `memory_status` — counts, and whether semantic search can answer now
- `index_memory` — bring the search index up to date
- `export_memory` — return everything the workspace holds as Markdown (ledger, daily entries, notes, retired), paged
- `preview_import` — dry run of an import of Markdown notes
- `apply_import` — apply a previewed import
- `undo_import` — retire the notes one import created
- `whats_new` — read: open requests for this connection, then what other agents saved since its last call
- `ask_agent` — write: a request to another named agent; it does not run a tool or wake that agent
- `list_requests` — read: requests this connection is a party to, newest first
- `answer_request` — write: an answer to a request addressed to this connection
- `close_request` — write: close a request this connection asked or was asked

Source: the registry in engine/src/mvp/server.ts, mapped in engine/docs/architecture/MCP-TOOL-SURFACES.md. If your client lists different tools, trust its tools/list and tell us. The same list is served as Markdown at /agents.md.

## Speed

The measurement we have, taken on 2026-10-06 from one network location: a hosted `get_context` takes about 430 to 500 ms at the median. The engine’s own work is about 20 ms of that (a search by meaning and a keyword search), measured separately on a test workspace shaped like the live one (87 notes, 1,845 chunks, 994 fact rows). The rest is the network between you and the gateway (about 143 ms), one account lookup (about 95 ms) and, for a query it has not seen, the embedding call to Vertex (about 140 ms). A save is similar: the engine spends 4 to 5 ms and the embedding of the saved text about 130 ms or more.

This is one day, one place and a load that was not quiet; the report says so. Expect more on the first call after a workspace slept, and less if you are close to the gateway. We publish no latency guarantee.

Source: data/renor-engine-latency/report.md (section 0); engine/apps/gateway/README.md (about 506 ms p50 hosted call).

## What Renor does not do today

- Self-hosting runs the engine alone. The engine is open source under Apache-2.0 at https://github.com/renorai/renor-engine; the website, dashboard, sign-up and operations come only with the hosted service.
- It does not record your conversations. A fact or note exists only because an agent or you saved it, and your host application decides whether the agent calls get_context at all.
- It does not notice that a plain note contradicts another note.
- It has no per-agent permissions, and no sharing of one memory between people.
- Its self-serve permanent deletion covers retired notes, log entries and facts, on the dashboard; a whole account is deleted under Settings → Delete account, or by email to privacy@renor.cloud.
- It documents no REST API for memory; MCP is the interface.
- It has not yet completed an independent security audit, and there is no uptime guarantee (SLA) on the current plans. Live status and uptime history: https://status.renor.cloud. See [Security and your data](https://renor.cloud/security).

## Questions people ask first

**What exactly is stored?**

Three kinds of thing: facts (a subject, a predicate and a value, with the sentence you said), notes (your words, whole, filed under the day they were saved) and, if you import them, Markdown notes from a vault. Nothing is stored unless an agent or you saves it: Renor does not record your chats.

**How are memories created and updated?**

An agent calls remember (or save_memory, or remember_note). A fact is replaced only by saving a new value for the same subject, predicate and scope; the old value stays in history. A note is never replaced by a later note.

**Embeddings, a graph or summaries?**

A ledger of facts with validity dates, plus search over notes by exact words and by meaning (embeddings; every hosted workspace has this on). A workspace without an embedding provider would match exact words only. Retrieval follows [[wikilinks]] between notes: a note linked from a match can be added as a further match (its reason is graph). Renor does not build a knowledge graph from your text. A summary is written at save time only on deployments where the optional write-time digest is switched on; it is off by default.

**What if two memories contradict each other?**

If both are facts under the same subject, predicate and scope, the newer one is current and the older one is history; that is the PostgreSQL to SQLite case above. If the contradiction is between two plain notes, or two spellings of a subject, Renor keeps both and cannot tell which is current. When facts disagree across scopes or under names one word apart, get_context lists the disagreement in a conflicts field instead of picking one.

**How does retrieval decide what to inject?**

Renor does not inject anything. Your agent calls get_context, and the host application decides whether and when it does that. The reply holds the current facts, then the notes that match best, cut to a token budget (800 by default, at most 4,000). When nothing on file closely matches, the reply says so (relevant: false) so the agent can answer that it does not know.

**Can several agents read and write the same memory?**

Yes: every MCP client you sign in belongs to one workspace and reads and writes the same memory. Each memory records the name of the app or agent that saved it. See “Several agents, one workspace” for what that does and does not guarantee.

**Can I export everything?**

Yes. export_memory returns everything the workspace holds in one documented format (renor-export/v1): the fact ledger with superseded values, every daily-log entry, every note in full, and everything retired, each with its metadata. A manifest counts each kind, and a large workspace is paged, never cut. See “Export and import”.

**Can I delete individual memories?**

You can retire one: it leaves every read and search at once and can be restored. Retiring is not erasure: a retired note or log entry stays in your workspace until you delete it permanently on the dashboard’s Memories page. A retired note keeps counting toward storage until then; a retired log entry stops counting as soon as it is retired. Deleting permanently cannot be undone, and only you can do it there; agents cannot. A retired saved fact is erased there too: its subject, predicate, value and statement leave the history record, search, the activity log and your export, and the history record keeps one line with none of those words (the event id, the time and a digest). To delete your whole account and memories, use Delete account in the dashboard’s Settings, or email privacy@renor.cloud.

**What happens if the service is unavailable?**

Your agent’s call fails with an error and nothing is written. There is no local copy that catches up later. See “When the workspace is asleep or unreachable”. There is no uptime guarantee (SLA) on the current plans.

**Is there an API or MCP interface? Can I self-host?**

There is one MCP endpoint, https://mcp.renor.cloud/mcp, with 24 tools. Renor documents no REST API for memory. The memory engine is open source under Apache-2.0 at https://github.com/renorai/renor-engine and can be self-hosted with its README. The hosted service adds the website, dashboard, sign-up and operations around the same engine.

**How much latency does it add?**

About half a second per hosted get_context call at the median, almost all of it network and account lookup rather than search. See “Speed”.

## Built for AI power users.

Start free. Create an account in minutes — no card, no waiting list.

[Get started](https://app.renor.cloud/signup)

[Renor home](https://renor.cloud/) Durable memory for AI. Your agents stop starting from zero.

Product [How it works](https://renor.cloud/how-it-works) [Docs](https://renor.mintlify.app) [Research](https://renor.cloud/research) [Culture](https://renor.cloud/culture) [Press](https://renor.cloud/press) [Install](https://renor.mintlify.app/install) [Blog](https://renor.cloud/blog/) [Pricing](https://renor.cloud/pricing) [Status](https://status.renor.cloud)

Account [Get started](https://app.renor.cloud/signup) [Sign in](https://app.renor.cloud/login)

Legal [Security](https://renor.cloud/security) [Privacy](https://renor.cloud/privacy) [Data protection](https://renor.cloud/lgpd) [Terms](https://renor.cloud/terms) [Refunds](https://renor.cloud/refund) [Support](https://renor.cloud/support)

© 2026 Renor

- [Renor on X](https://x.com/renor_ai)
- [Renor on LinkedIn](https://www.linkedin.com/company/renorai/)
- [Renor on YouTube](https://www.youtube.com/@renor_ai)
- [Renor on Twitch](https://www.twitch.tv/renor_ai)
- [Renor on Instagram](https://www.instagram.com/renor.ai/)
- [Renor on Threads](https://www.threads.com/@renor.ai)
