EMET
EMET is a persistent, write-verified shared memory server for AI agents — it stores layered memory, word-for-word transcripts and versioned documents in MongoDB, with no delete by design.
Session lifecycle:
emet_initialize(paged startup, returns identity/user/handoff and setup interview),emet_session_open,emet_transcript_append(one exchange per reply),emet_session_close(checks receipts and reportscomplete/blocked).Layered memory (6 layers):
save_to_layer(identity, semantic, episodic, procedural, meta, working), keywordrecall, structuredquery_layer, meaning-basedsemantic_recall(Atlas vector search), andrevise_memoryto supersede (episodic is immutable).Verbatim transcript tier:
save_transcript,revise_transcript,query_transcripts— reads the live store and the legacy 2025–2026 exchange archive.Versioned document store:
read_doc(paged),write_doc,patch_doc(exact substring edits),list_docs,read_doc_history(retained revisions),retire_doc,rename_doc,restore_doc, plus staged large writes (write_doc_begin/_append/_commit/_abort).Document control (ISO 9001/13485 style):
validate_docchecks a document against its template;accept_nonconformancerecords a written disposition; records are superseded whole, never patched.Topic pages:
emet_page,emet_pages,emet_page_lint— generated, cited views of current records (not stored, owner-only).Integrity & audit: every write read back and compared;
emet_status(withprobe: truewrite-path test),emet_gaps(unsourced assertions, digest mismatches, broken supersession, etc.),emet_error_report.Behavioral grounding:
emet_floorreturns the standing floor/character (including installed GEM floors) at any point in a session.Access control:
emet_client_approve(owner approves writer tags),emet_invite_create(read-only guest codes),emet_member_access_create(read-write member codes); per-client attribution on every write.Guarantees/limits: nothing is ever deleted — corrections are added, retired items stay readable; first writes need a session and machine line; validation checks form, not truth.
Stores agent memory in MongoDB (Atlas or self-hosted) as the server's persistent backing store, persisting curated claims, layered memory records, and the separate verbatim transcript tier across sessions and hosts, with every write read back for verification.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@EMET remember we chose MongoDB Atlas, then read it back to verify"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
EMET
EMET is an MCP (Model Context Protocol) memory server, persistent shared memory for AI agents, bot teams and chats.
אמת — Hebrew for truth. Also Enduring Memory & Epistemic Tiers.
Website: https://dreamforgestudiollc.github.io/EMET/
See also: CHANGELOG · CONTRIBUTING · SECURITY · Charter · One instance per project · Feature map · Development practices
What it does
Layered memory. Six layers — identity, semantic, episodic, procedural, meta, and working — hold curated claims, split by what kind of thing an entry is.
Verified writes. Every write is read back and compared before it is reported as saved.
Word-for-word transcript tier. A separate tier stores the conversation as it was written, so a summary cannot overwrite the record it came from.
stdio and remote HTTP with OAuth. The same server runs locally over stdio, and remotely over HTTP with OAuth. The transport changes. The store does not.
MongoDB. Atlas, or MongoDB you run yourself. A one-machine trial can use MongoDB 6 or newer. Only
semantic_recallneeds Atlas.Golem Expertise Module (GEM) socket. Add-on behavior ships as GEMs, seated at startup and checked by
gem-checkagainst the GEM standard ingem-library/. A GEM ranks below the core floor and below the user's current word, and cannot remove a protected floor line. Two work-in-progress examples ship bundled and stay off unless you ask: Neurendipity (neurodivergent engagement and autistic burnout support; support only, not counseling or treatment;EMET_ACTIVE_GEMS=neurendipity) and Lean Six Sigma (DMAIC and DMADV guidance, templates, and client-side calculators;EMET_ACTIVE_GEMS=lean-six-sigma). Fieldnote stays in the tree as a developer case-study of a runed GEM. It is not a user-facing third GEM, and it is off by default.Bot-team backup (optional). Off unless the first-run interview records yes. Yes is the recommended choice. The recipe and the recovery template ship as the bundled bot-team-backup GEM. EMET does not copy prompts or settings itself, and secret values are never stored.
Client-side GEM execution. A GEM may declare a tool. EMET does not run that computation. EMET verifies the record, not the computation. The client runs the tool, and what is written back is checked the same way as any other write.
Released flag. A GEM is seated only when its released flag is the boolean true. Any other value is refused. A missing flag is refused except for a legacy manifest pinned by id, version, and file digests.
Per-client attribution and approvals. Every write is attributed to the client that made it. A new client is read-limited until it is approved. The approval is recorded.
Error codes and problem reports. Every error carries a stable
EMET-<AREA>-<NNN>code. An operational error log keeps 10,000 entries or 90 days, plus daily summaries. The owner-onlyemet_error_reportreturns the report and an email draft that you send yourself. See Reporting a problem.verify-emet and the feature map.
npm run verifyrunsscripts/verify-emet.mjsfrom a checkout. It starts EMET in a temporary directory on the in-memory test database, with no.env, and drives every registered tool. A tool that needs a service a plain install does not have is reported as a gap. A run whose only problems are gaps exits 3. A failed tool exits 1. The map is docs/features/README.md.MIT. Version 0.3.6. EMET is still 0.x: stored document shapes may change before 1.0. Pin a version if you depend on them.
Roadmap. What is proposed, planned, or a later phase is docs/ROADMAP.md. An item there is not built unless it says so. Upcoming work is labeled Proposed, Planned, or Later phase. Discussion is in GitHub issues.
The store has one owner, and other people can join only through the optional Guest (read-only) and Member (read and write) access, both off by default.
Related MCP server: io.github.admiralpunk/provena-memory
Document control (ISO 9001 7.5.3 / ISO 13485 4.2.5)
EMET is built for document control in environments that work under ISO 9001 and ISO 13485. It supports that work; it holds no certification and claims no conformity. An organization that uses it stays responsible for its own quality system, including validating EMET for its intended use.
No delete, on any store, by design. No tool removes a memory entry, a document or a transcript. The database role EMET runs under is not granted remove on the record either.
Corrections are made by adding. A memory entry is superseded by a revision that stands alone. A document is revised or retired. A transcript part is revised. Events are never rewritten.
Retired means obsolete, not gone.
retire_docmarks a document obsolete and keeps its id, content, version and digest.read_docstill returns it, flagged retired, with the reason.Prior versions are retained. Every document write archives the copy it replaces, and
read_doc_historyreads any retained revision back, checked against its stored digest.Records are superseded whole, never patched. The handoff and any other record document cannot be patched. A new revision is written in full and names the version it supersedes.
Templates are controlled documents. Base templates ship with the release, and the shipped copy governs. Every templated write is checked against its template, and a write that fails is kept and marked for review, never silently accepted or discarded.
A test holds the line.
write-path.test.jsfails if anything insrc/removes from a layer, document or transcript collection, andatlas-role.test.jsfails if the database role grants remove.
Start here
npm install
cp .env.example .env
npm startNode.js 22 or newer. Fill in MONGODB_URI and MONGODB_DB. .env is gitignored.
Guided setup: docs/GUIDED-SETUP.md — never deployed anything. Your assistant installs, configures, deploys, and verifies. You sign in when asked and paste the connector URL.
Setup: docs/SETUP.md — the manual walkthrough: MongoDB, both transports, and the first-run interview.
Deploy: docs/DEPLOY.md — remote HTTP with OAuth, so a phone, a browser, or another vendor's agent reaches the same store.
What is next: docs/ROADMAP.md — Upcoming work is labeled Proposed, Planned, or Later phase, and it is not built unless the page says so.
Status: 0.x. The stored document shapes are not frozen yet. Breaking changes to the schema may land before 1.0. Pin a version if you depend on it.
Set
EMET_SOURCE_TAGSbefore you let more than one host or bot write. The source-tag guards (unregistered tags refused on the main records, and on another bot'sbots/folder) are off unlessEMET_SOURCE_TAGSis set. With it unset, any caller can write under any tag. See.env.exampleand docs/DEPLOY.md.
Install as a Cursor / Grok Bot plugin
EMET ships a plugin for Cursor and Grok Bot (this repo's .cursor-plugin/plugin.json and
mcp.json). The Cursor Marketplace listing is submitted and pending review. The plugin does not host memory for you: it connects to your own EMET
server, so your records stay in your MongoDB.
Deploy EMET remotely: docs/DEPLOY.md. Set
PUBLIC_URLand a strongEMET_OAUTH_PASSPHRASE. Checkhttps://<your-host>/healthreturns{"ok":true,...}.Install the EMET plugin and set the variable
EMET_URLtohttps://<host>/mcp.Connect. The OAuth sign-in opens EMET's passphrase page; enter your passphrase once per device.
Verify: call
emet_statuswith{"probe": true}(it writes, reads back and removes a row from_emet_verifyonly), then save withsave_to_layerandrecallit from another client.
The plugin also ships an emet-memory skill that tells the agent when to recall, save and close
a session.
Shared memory across hosts
EMET stores agent memory in MongoDB (Atlas or self-hosted) across six layers, keeps a separate word-for-word
transcript tier, and verifies every write by reading it back. It runs as a local stdio server
and as a remote HTTP server from the same source, so it works as a bridge: AI models on several
hosts — desktop, CLI, browser, phone, another vendor's agent — read and write one shared
memory, and the work, checks, and decisions one leaves behind are there for the next. That
includes Grok Bot teams and single-session Grok chats connected to the same server: what the
bots save is there for a fresh Grok chat to find once it initializes, and the reverse. To
connect a single-session chat (a Grok project, or any chat host that takes a remote MCP
connector and supports its OAuth sign-in), add your deployed server's URL,
https://<your-host>/mcp, as a remote MCP connector there and complete the sign-in with the
passphrase you set (EMET_OAUTH_PASSPHRASE; see
Connecting clients). A connector that only takes a fixed
header or key will not work. Then put the instruction block from
docs/BOOTSTRAP.md in the project instructions: the chat reaches for that
memory most reliably, unprompted from the first turn, with the block there, or, as a fallback
where there is no such field, with it pasted as the first message. The store has one
owner, and other people can join only through the optional Guest (read-only) and
Member (read and write) access, both off by default.
Two ways in
A session that has not initialized can read everything and can write only a new drop (drops/<date>-<slug>.md): its items, wrap-up and handoff. A session with a registered source and the full startup has full access. Every initialized session sees unhandled drops first. A board edit is refused only for a drop that was listed at that session's boot. New drops are capped at 20 per New York day, in one bucket: the whole local process on stdio, one shared visitor bucket for HTTP with no signed-in client, the source tag bound at approval when there is one, or that OAuth client otherwise. A source the caller types does not move the bucket. Drops are never deleted.
Editing working state
The server provisions a blank board at setup. No session can write the board. It is edited with patch_doc and a reason; an added row names its origin. Once any working document exists, it is edited, not rewritten. A change that leaves a document under half the size it had when this session first touched it, or under half of its largest size in the last 24 hours, is refused. retire_doc refuses a working document. rename_doc issues a new id and marks the old id retired; the text stays readable and stays in the list. restore_doc is the one whole-document recovery, for an owner-listed tag, and only a stored conforming revision whose digest matches.
The name
EMET is אמת — Hebrew for truth. It is also an acronym for what the server does: Enduring Memory & Epistemic Tiers.
The choice is not decoration. In the golem legend the word emet is inscribed to animate the body, and erasing its first letter leaves מת — met, dead. One character is the whole difference.
That is why the verification layer is called aleph. Every write in EMET is read back and
compared before it is reported as saved. That read-back is the aleph: a memory system without
it still returns answers, still looks healthy, and is quietly a corpse — confidently serving
things it never actually stored. Aleph is also the first letter, which matches the order the
protocol insists on: verify before retrying, verify the premise before applying the remedy,
read back before trusting.
The same image explains what setup is for. A golem is inert until the word is written on it;
a fresh model instance is unformed until the record is written into it. emet_initialize is
that inscription — it hands the model an identity, the person it serves, where things stood,
and the disciplines it is bound by. Nothing mystical is claimed here. It is a literal
description of what the first tool call does.
Both halves of the acronym are load-bearing.
Enduring is not a modest claim, and it is not a feature competing with other memory products. It is measured against what a language model is by default: an etch-a-sketch. Every session starts from nothing, and ends by forgetting everything. You explain yourself again, re-establish what you are working on again, re-derive decisions you already made. Enduring names the difference between an assistant that knows you and one meeting you for the first time, again. That is the character of the thing, not a marketing adjective attached to it.
Epistemic Tiers is how that endurance stays trustworthy. Tier 1 holds curated claims; tier 2 holds the verbatim record that justifies them — justified belief and its evidence, kept structurally separate so neither can quietly overwrite the other. Memory that persists but cannot be checked is just confident noise that survives longer.
One memory, every device
This is the part worth understanding before anything else.
Most MCP memory servers run as a local process: your desktop launches it over stdio, and the memory lives wherever that process can reach. That works until you pick up your phone.
EMET ships two entry points over one source tree:
| stdio | desktop and CLI, launched by the client |
| streamable HTTP + OAuth | phone, tablet, browser, another vendor's agent |
They are not two projects. Both call the same dispatchTool in dispatch.js, which calls
tools.js and database.js. src/index.js also imports validation.js. src/http-remote.js
does not import validation.js or content_analyzer.js; tools.js imports the analyser. The
transport is the only thing that differs. There is no fork to keep in sync, no second copy
drifting out of date, no "mobile version" lagging the real one. A fix lands once and both
transports have it.
Deploy the HTTP entry point to any host that can run a container — the Dockerfile is
included, and docs/DEPLOY.md walks through Railway and Fly — and every device
you own reaches the same store. Write a decision from your laptop, ask about it from your
phone an hour later, and it is simply there. Add a third host and it joins the same memory
rather than starting its own.
The remote endpoint is OAuth-protected: a device is authorized once with a passphrase you set,
and the token persists across restarts and redeploys. Leave EMET_SOURCE_TAG unset on a
server several hosts share. Over HTTP, document, transcript, and memory writes use the source
tag bound at approval. A local stdio host still passes an exact tag from EMET_SOURCE_TAGS
as source on its writes (see .env.example). Every entry records which machine produced
it — with several hosts writing to one store, provenance stops being optional bookkeeping and becomes the thing that lets you trust
what you read.
Running cost for a single user is a small MongoDB cluster plus a hobby-tier container host. Both have free tiers adequate to start.
Best practices
Split the work by what each host does best. A single-session chat (for example, a Grok project chat, connected as described at the top) only works when you send it a message. It can't watch EMET, and bots can't message it. So when a bot team needs the chat's help:
The bots leave a task in EMET with everything needed to do it, in a document whose id they give you.
You send the chat one line that names that document, for example: "Initialize EMET, read threads/open-tasks.md, do the task, and save the result to EMET."
The chat saves its draft to EMET.
The bots check it.
Good fits for the chat: long drafting and review done in one sitting. Good fits for the bots: work in the repository, on the server, on a schedule, or in accounts. If the chat runs on a separate plan, its work draws on that plan's allowance, not the bots'.
Fetch every startup page, then open the session with that startup's load_id. Call
emet_initialize {} first and fetch every page it names; ask for {"page": "all"} only on a
host known to read long results whole. Pass the load_id from those pages to
emet_session_open. An open with no load_id, with a page missing, or with a load_id the
server has no record of (one from before a restart, or 60 minutes past its last page) is
refused, and the reply says what to call. The page check runs on your own startup, and a
skipped page is refused before anything is written. After every reply, append that one
exchange. The first successful append must carry the measured machine line, or the words
no local shell MCP. A refused exchange 1 does not let a higher index open the transcript.
At the end, follow session_close_protocol and call emet_session_close. Say the session
is saved only when the state is complete. A skipped step is refused and nothing is written.
There is no off switch. See docs/BOOTSTRAP.md
and docs/BOTS.md.
Set the source-tag list before more than one host or bot writes. The guards that refuse
an unregistered tag are off unless EMET_SOURCE_TAGS is set; with it unset, a stdio caller can
write under any tag. Over HTTP the tag is the one bound when that host was approved. Add each
host's tag to the list before that host's setup interview. With several hosts writing one store,
the tag is what lets you trust who wrote what. See docs/SETUP.md.
Put the instruction block in the project's instructions. Connecting the server gives the assistant the ability to remember; it does not make it use that ability. A host with an instructions field is the strongest integration: paste the block from docs/BOOTSTRAP.md there. Where there is no such field, paste it as the first message of a session. With the block in place, the assistant reaches for memory most reliably from the first turn, instead of answering from what it can infer and saving nothing.
Approve reads standing, and keep an eye on the three writes that replace a document. Reads cost nothing and cannot be wrong destructively, so a reasonable default for most users is standing approval for reads. Additive writes are recoverable, because a correction supersedes what it corrects rather than overwriting it. The three replacing writes archive the prior version, but a wrong one is silently a different document rather than an error. Do not carry this posture to a filesystem or shell server. See docs/PERMISSIONS.md.
Reconnect each host after an upgrade that changes the tool list. Hosts cache the tool list: after a deploy that adds or renames tools, each host keeps offering the old set until you reconnect the connector there. New tools stay invisible until the host sees the new list, and the host may ask again for approvals you had already given. See docs/DEPLOY.md.
Register a bot before its first write, and set both lists in one change. One bot, one tag,
<prefix>-<bot> (for example bot-reviewer). When a bot joins the roster, append its tag to
the end of EMET_SOURCE_TAGS, keep every existing tag in order, and add
bots/<tag>/HANDOFF.md to EMET_RECORD_DOCS before its first write. Set both in one
deployment. Setting either variable redeploys the server; afterwards, check /health and
emet_status. A registered tag that is not listed as a bot can still write the main records.
The hub's tag is registered as a host and is never listed as a bot. That standing rule is
docs/BOTS.md §4.
Approve a writer yourself, and give a bot that shares your login its own key. The owner
decides a new writer on /owner/chooser. An AI does not grant a writer. When EMET_SUBKEYS=1,
each bot that can keep a key file holds its own emk_ key. The owner approves that key on the
same page. The bot presents the key once at emet_session_open. See
docs/SUBKEYS.md and docs/BOTS.md §4.
Pass session_handle on every write in a sub-key session. emet_session_open returns
session_handle once. Later writes in that session pass session_handle. A write that names
the session and omits the handle, or sends a different one, is refused, and nothing is written.
The handle is not a receipt and is not written into a document. With sub-keys off, the field is
absent. See docs/SUBKEYS.md and docs/PERMISSIONS.md.
Prove the write path before you trust a new deploy. Run emet_status with probe: true.
It writes a test document, reads the same value back and removes it; a read alone cannot show
a broken write path. A role missing a permission fails there, loudly, instead of in the middle
of a session. Then save something from one device and recall it from another. See
docs/SETUP.md.
Keep house style in the store, not pasted into every project. A document written with
write_doc is read by every host and changed in one place; text pasted into three projects is
three copies that will disagree. Delivery preferences belong in bootstrap/USER.md, not in one
vendor's own memory, which does not travel to the next host. See
docs/BOOTSTRAP.md.
Attribution
EMET is a derivative of CASCADE Enterprise RAM by Jason Glass / C.I.P.S. LLC, published
at github.com/For-Sunny/cascade-memory-enterprise, used and redistributed under the MIT
license the project adopted at commit acdb5c8c99cdfc29fb44db2cd828d7752be744db (v2.2.2,
2026-02-19). Both copyright lines are retained in LICENSE.
Link unavailable: as of 2026-10-03 that repository no longer resolves (GitHub answers 404), and no moved copy, public mirror or archive of it was found. The address and commit are kept here as the record of where this code came from.
How much is upstream, measured rather than estimated. Line-level comparison of this tree against upstream v2.2.2 at the commit named above.
Method, stated so it can be reproduced: exact, case-sensitive comparison of non-blank
lines; an upstream line counts as retained if the same line is present in this tree's file.
"How much of upstream survives here" and "how much of this file is upstream's" are different
questions with different answers, so both are given. scripts/measure-upstream.mjs
regenerates this table against a clone of the commit above (while the upstream repository is unavailable, that needs a copy kept from before) — run it after any change to
src/, because a figure nobody can cheaply re-derive is a figure that goes quietly stale.
File | Lines here | Upstream lines retained | of upstream | of this file |
| 450 | not recomputed | — | — |
| 1163 | not recomputed | — | — |
| 390 | not recomputed | — | — |
| 4273 | not recomputed | — | — |
| 811 | not recomputed | — | — |
| 269 | — | — | no upstream counterpart |
| 702 | — | — | no upstream counterpart |
| 206 | — | — | no upstream counterpart |
| 26 | — | — | no upstream counterpart |
| 4803 | — | — | no upstream counterpart |
Lines here were counted on 2026-10-07 (every line, including blanks, with one trailing empty line dropped). The retained percentages were not recomputed: the upstream repository no longer resolves, and no local copy of that upstream commit was available. The last measurement, against an earlier tree, was content analyser 361 of 394 (91.6% of upstream, 93.5% of that file), validation 765 of 798 (95.9%, 78.2%), index 541 of 631 (85.7%, 74.0%), tools 798 of 1007 (79.2%, 33.2%), and database 353 of 651 (54.2%, 40.2%). Other files under src/ also have no upstream counterpart and are not in this table.
Upstream's server/decay.js and server/healthcheck.js have no counterpart here and are not
carried at all. Of the five files that do have one, the content analyser and the validation
layer are substantially Jason's work, and most of his tools.js and index.js survives here
as well — the routing patterns, the validators, and the error classes are his. What changed is
described below; what did not change is his.
What diverged from upstream
Storage: SQLite on a RAM disk → MongoDB. Upstream's
ram_disk_managerandserver/decay.jstemporal-decay engine are not carried forward, and the SQLite/RAM code paths have been removed rather than left dormant.Transport: stdio only → stdio and streamable HTTP with OAuth, from one source tree.
Tools: 7 → 29. Three are carried from upstream (
recall,query_layer,save_to_layer);remember,get_stats,get_echo_statsandget_statusare dropped as duplicates or folded intoemet_status. Twenty-six have no upstream equivalent — the document store (read_doc/read_doc_history/write_doc/list_docs/patch_doc/retire_doc/rename_doc/restore_doc/validate_doc/accept_nonconformance), the transcript tier (save_transcript/revise_transcript/query_transcripts— which also reads the pre-2026-07 exchange archive),semantic_recall,revise_memory,corpus_recall,emet_gaps,emet_floor, the setup and session family (emet_initialize,emet_status,emet_setup_complete,emet_session_open,emet_transcript_append,emet_session_close), and the two access doors (emet_invite_create,emet_member_access_create).The write path: upstream validates and inserts. Here every layer write, transcript write and document write passes through one door that scrubs secrets, decides the source tag, fills missing accountability fields with visible markers, digests content and metadata into their own columns, reads the row back, and returns one receipt shape. A test fails the build on any second door. See The door below.
Metadata vocabulary: upstream's whitelist relocated any field it did not know under
custom. EMET's own fields —supersedes,superseded_by,superseded_at,corrects,corrected_by,valid_until,valid_from,routing,assertion_origin, and the marker booleans — are first-class, and anything that is still relocated is named in the receipt.Charter as data:
layers.jscarries, beside each layer's prose, its numeric importance band, whether it may be revised, whether provenance is required, its aliases and its expected share, and the write path reads those rather than hardcoding them.
No claim is made that layered memory, entry supersession, or a split curated/verbatim store originate here. Comparable ideas ship in other projects. EMET's aim is that the substrate is not something you have to think about.
Install
Never deployed anything? Let your AI do it: docs/GUIDED-SETUP.md. You sign in to two services when asked and paste one URL; the assistant installs, configures, deploys and verifies the rest. It needs a shell — Claude Code and Cowork have one; Claude Desktop gets one from an MCP server such as Desktop Commander (one command, in the guide).
Full walkthrough: docs/SETUP.md — Atlas, both transports, and the first-run interview. Deploying remotely: docs/DEPLOY.md. Making your assistant actually use it: docs/BOOTSTRAP.md. Running bots alongside your assistant — registering their tags, their own handoffs, the session loop: docs/BOTS.md. For designing a bot team, see docs/SUBKEYS.md.
Continuous chats. A bot in a long-running chat saves its transcripts to EMET
word for word at least nightly (a checkpoint), under the open session or a daily
YYYY-MM-DD_chat-daily session. Prefer event triggers over time-based polling.
When polling is unavoidable, use the longest interval the job allows. Never
reconstruct turns. Mark gaps as gaps. Session close cites those saved parts.
Context compression erases older turns, so a close days later cannot invent the
transcript.
Short version:
npm install
cp .env.example .env # fill in MONGODB_URI and MONGODB_DB
npm startRequires Node 22+ and a MongoDB connection. .env is gitignored — never commit it.
Local (stdio) — as an MCP server entry:
{ "mcpServers": { "emet": { "command": "node", "args": ["/path/to/emet/src/index.js"] } } }Remote (HTTP) — npm run start:http, or deploy the included Dockerfile to any container
host. Set PORT, PUBLIC_URL (the OAuth issuer — it must match the deployed URL exactly) and
EMET_OAUTH_PASSPHRASE. Then add https://<your-host>/mcp as a custom connector in each
client. See docs/DEPLOY.md.
Give every host its own source tag. Over HTTP, document, transcript, and memory writes use the
tag bound at approval; the caller does not pass source on those writes. A local stdio host
still passes an exact registered tag as source. EMET_SOURCE_TAGS registers the tags. Leave
EMET_SOURCE_TAG unset on a server several hosts share, since a default tag makes every
host look the same; set it only where one host uses the server (a local stdio entry, for
example). Every write records the host that produced it; a shared default tag is ambiguity
rather than attribution.
First run
Say "initialize". That is the whole interface.
emet_initialize is the front door and the only thing anyone needs to know about. On a new
store it returns a short interview — what the assistant should be called, how it should carry
itself, your name, what you are using this for, and whether more than one bot or AI will use
this memory — which your assistant runs conversationally,
then records with emet_setup_complete, which also creates the owner person. Whether more than one bot or AI will use this memory is optional; leaving it out leaves delegated client sub-keys off. A yes writes them only when this server reads .env, and they take effect on restart. A hosted server refuses and tells you the three variables to set, then redeploy. See docs/SUBKEYS.md. On an established store the same call returns the
assistant's identity, your profile, and where things were left, so the session opens already
knowing you. A read-scoped emet_initialize writes nothing; a write-scoped one may provision a missing board. First-time setup is the owner's:
emet_setup_complete is refused under a bot tag, and on a store that is already set up it is
refused unless reissue: true is passed on the owner's explicit word.
Requiring a setup command would have been backwards: the one time you need it is the first session, before you have read anything. So the branch happens inside the tool, and you never have to know which case you were in.
Connecting the server gives your assistant the ability to remember; it does not make it use that ability unprompted. docs/BOOTSTRAP.md has a short block to paste into your project instructions, and explains what still works on hosts that have no instructions field at all.
Two behaviours worth knowing. Setup refuses to finish on partial answers rather than inventing an identity for itself. And if the store cannot be reached, initialize says so plainly instead of proceeding as though memory were available — fabricated continuity is worse than an honest gap.
Every session after that: how to start, how to end
Memory is only as good as the two moments at the edges of a conversation. Nothing your assistant learned survives unless it was written to the store, and the moment to write it arrives without warning — a closed tab, a context limit, a phone call. So every session has one word at the start and one at the end.
Start: say "initialize". Your assistant calls emet_initialize, fetches every startup page, opens the session with that startup's load_id, and returns who it is,
who you are, where things were left and the operating disciplines, and picks up from there.
Before it asks you anything, it names your items from the handoff and state documents: anything
left half-finished, what is dated in the next seven days, each open item you own with its next
action, and whatever was left undecided. An item not named at the start of a session is easy
to lose, so a count or a bare "where do you want to start?" is not treated as a startup.
Do this in every new conversation, on every device — the first message, before the question
you actually came to ask. A session that skips it is a session that answers from guesswork
and saves nothing.
End: say "wrap up" (or goodbye, or that you are opening a new session). Your assistant
appends each exchange as the session runs. The first successful append carries the measured
machine line, or the words no local shell MCP. It then follows session_close_protocol
(working documents, the episodic entry, the board, the transcript already appended, and the
handoff last) and calls emet_session_close, which checks that each one
actually landed and returns state: "complete". Wait for that word before you close the
window. If it comes back anything else, something did not save, and the assistant will say
which. A skipped step is refused. Nothing is written for that step. The next session cannot
see work that never landed.
Why both, every time: the layers are curated meaning and the transcript is the word-for-word
record; the next session reads the first and can reach into the second by timestamp. Close
without the ritual and the next session inherits a hole — it cannot see what happened, only
that something did, and emet_gaps will count it. Start without it and the assistant is a
stranger with your tools. The instruction block in docs/BOOTSTRAP.md
makes both of these automatic on hosts that take standing instructions; on hosts that do not,
the two words are what you supply.
Design notes
The six layers
Memory is split by what kind of thing an entry is, not by topic. Each entry carries an importance score and optional temporal validity.
Layer | Holds | Importance | Written |
identity | Who the assistant is and who it serves. Durable self-definition and the user's standing requirements. | 0.9 – 1.0 | Rarely, by design |
semantic | Facts that stay true regardless of when they were learned. People, systems, definitions, established conclusions. | 0.6 – 0.9 | When a durable fact is established or corrected |
episodic | What happened, and when. Session records, problems solved, progress through long work. | 0.4 – 0.7 | At session close and at milestones |
procedural | How something is done, and decisions that govern future action — with the reasoning. | 0.5 – 0.8 | When a decision constrains later work |
meta | Everything visible only from outside the exchange: how the memory system behaves, and how the assistant behaves toward the user. | 0.6 – 0.9 | On retrieval failures and wins, protocol drift, and corrections to how the user is worked with |
working | Short-lived context, in-flight state, notes for whoever picks the work up. | 0.3 – 0.6 | When parking state between sessions |
The distinction that does most of the work: episodic, semantic and procedural are about the world — what happened, what is true, how something is done. Meta is about the system — looking back at the exchange from outside it. Material belonging in meta feels like nothing else fits it, which is precisely why it gets discarded when meta has no definition.
Every layer works from the first install
Creating six collections is not the same as having six layers. A layer with no stated charter has no answer to "does this belong here?", so nothing routes to it — and an empty collection throws no error and fails no test, so it can stay empty indefinitely without anyone noticing.
In the deployment this design came from, the meta layer sat nearly unused for about a year. The collection existed from day one and the tools accepted writes to it; it was simply never the obvious place to put anything. When it was finally given a definition it filled immediately — which is the proof that the material had been there all along and was being thrown away.
Two things in this repo exist because of that:
src/layers.jsships the charter for all six layers in code, andemet_initializereturns it — on a brand-new store as well as an established one. Same reasoning as the operating disciplines: documentation is read by people, and this has to reach the model at the start of every session. What belongs, what does not belong, when to write, when to read, and what the layer's absence looks like.assessLayerHealth()reports a layer that has gone dark. A store cannot know what should have been written, but it can see that one layer took almost nothing while the others filled, and say so in the first payload of the next session. Run against the real history above, it flags meta at 10 entries / 1.8% of the store — and goes quiet once the layer is in genuine use. It reports; it never blocks, and it stays silent on a store too new to have a pattern.
Two tiers, deliberately independent. Layer entries are curated meaning; a separate transcript store holds the word-for-word conversation. When a layer entry is relevant but thin, the transcript holds the depth that was compressed out of it. Summarising at transcript-write time collapses the two tiers into one and destroys the second line of inquiry — so the transcript path stores exactly what it is given. If a payload will not transmit, split it across parts; do not compress it.
How tier 1 reaches tier 2 — two links, one precedence rule.
An entry records the transcript span it came from: session_id plus a range of exchange indices,
written at save time as derived_from. Entries consolidated from other entries carry
{entries: [id, ...]} instead, because an entry with no transcript origin must be able to say so
rather than carry a nearest-timestamp guess dressed as a citation. Both are stored as top-level
indexed columns rather than inside the metadata subdocument, so the reverse question — every
entry drawn from this transcript — is entirely a query.
Every entry also has a timestamp, so a window around it can always be searched. The two are not redundant copies: the pointer is exact but conditional, the timestamp universal but approximate — it depends on choosing the window, degrades when sessions overlap, and when it is wrong it returns the neighbouring span rather than failing.
Precedence is what keeps them from conflicting: the pointer wins whenever present, the
timestamp is the fallback when it is null. Never averaged, never combined, and the timestamp is
never preferred merely because it returned something. resolveProvenance() applies the rule so no
caller has to decide it.
Keeping both buys something neither gives alone — they can check each other. If an entry's
pointer names a session whose span sits nowhere near that entry's own timestamp, something is
wrong: a mis-written pointer, a field copied from another entry, an entry attributed to the wrong
session. crossCheckProvenance() reports the disagreement. Two independently derived answers that
can disagree is redundancy in the engineering sense; one link that can only be trusted is not.
The reverse direction — what did we take from this session? — is not a second structure.
source_session_id is indexed, so it is the same data read the other way. A stored reverse index
would be a mirror of data that already exists, and mirrors are how forks are born.
Entries written before pointers existed keep a null pointer and resolve by timestamp, and that remains correct for them — superseded, not wrong. They are not backfilled: the only way to invent a pointer for them is to infer it from the timestamp, which is exactly the weaker method the pointer replaces. Old records are not rewritten to look like new ones. Note also that an empty timestamp-window search is not proof that nothing was recorded — a period may hold no transcript at all.
Supersession, not mutation. revise_memory writes a new entry carrying supersedes and
marks the parent with superseded_by and superseded_at. Nothing is edited or deleted, and the
parent is not hidden. Recall ranks by how many of the query's words match, then by importance.
Current entries come first in every order, including time order. The store applies that same order before it keeps the window, so a stronger match is not dropped for a lower importance or an older time. A word matches as written, so $gt is that text, and capital and lower case match, including École and école. İ matches only itself. Full-width letters fold only with their full-width counterparts. ẞ and ß fold together. The store and the page use that same match. Time order is what you get
from order: 'latest'. A standalone "latest", "newest", or "most recent", together with other
words, reorders those matches and does not change which rows match. A hyphenated word such as
latest-budget, "not the latest", and a bare "latest" are ordinary keywords.
A superseded or expired entry stays in the same result, marked
with its end date and the id of what replaced it. Pass history: true when current matches fill
the limit and you still need the ended ones. Episodic entries
are immutable — events do not get revised.
Corrections, not supersession, for partial fixes. When a later entry corrects only part of an
earlier one (one item of an episode, say), superseding puts an end date on the whole parent,
including the parts that still stand. The parent stays readable, marked ended. Instead the new entry carries metadata.corrects: <parent id> (same layer; a missing
parent is refused before anything is written), and the parent is marked: its corrected_by list
gains the new id, its content, digest and liveness are untouched, and its metadata digest is
re-attested in the same write. Reads return corrected_by, so a reader of the parent sees that a
correction exists. corrected_by is a door marker; a caller cannot set it. Entries corrected
before this existed (e.g. episodic ref 604 correcting ref 603) carry no link; the fix is a new correction
entry naming corrects: 603, not an edit or a backfill.
Verified writes - src/aleph.js. Every write is read back and compared before it is
reported as saved. Document writes archive the prior version, then confirm both the sha256 and
the version; layer writes confirm the stored content at the id that was allocated. The id is
checked by content rather than existence on purpose: ids come from a counters collection, and a
counter read from the wrong collection restarts at 1 and silently overwrites real entries -
which looks exactly like a successful save.
A verification failure raises AlephError, deliberately distinct from a database error. A
database error means the store could not be reached and the write probably did not happen. An
AlephError means the call succeeded and the store does not contain what it should. That is
the more serious of the two and the one that must never be retried blindly, so it is never
flattened into "the save failed".
The aleph answers two questions, at two moments. At the write: was it recorded accurately?
The read-back above, before any receipt. At every later read: is it still what was
recorded? Each row carries its content and metadata digests, an HMAC signature over both
(when EMET_SIGNING_KEY is set; the key stays on the service), and a link in its layer's hash chain (each entry's chain
digest covers its own content digest and its predecessor's). Every read recomputes the digests
and reports integrity; emet_gaps walks the whole chain for any host and counts a row altered
after writing (broken_chain) or removed from mid-chain (chain_discontinuities). Expected
count for both: zero.
The door
Truth integrity, accountability and validation are meant to be a guaranteed property of the
store, not an option a model can decline to use. A file a model can be told about is a file it
can ignore. So the guarantee comes from a property, not a module: exactly one way to write
each store, with the checks inside it. saveMemory for the six layers, writeDoc for
documents (patch_doc delegates to it), saveTranscript
and reviseTranscript for the verbatim tier. tests/write-path.test.js scans src/ for every
MongoDB write verb and fails the build on any that sits outside those functions — it found and
removed a second document door in setup.js.
Inside the door, in order:
Secrets are masked before anything is stored or hashed (
src/redact.js): the literal values of secret-bearing environment variables (includingEMET_SUBKEY_PEPPER), credentials inside URIs, bearer tokens, JWTs, andkey: valuepairs whose key names a secret become*****. The mask is visible on purpose, the receipt'sredactedreports the number of spans this write changed (text already carrying the mask is left alone and not counted, so a read-modify-write of a document reports zero for the masks it already held), and the same scrubber wraps every rendered log line.The source tag is decided here, not by the caller over HTTP. Document, transcript, and memory writes use the tag bound at approval. On stdio it is the caller's exact registered tag, else the environment default marked
source_defaulted: true, elsenullmarkedsource_missing: true.Every missing accountability field becomes a visible marker rather than an absence —
provenance_missing,assertion_origin_missing,importance_defaulted,source_unregistered— because absence cannot be queried and "missing" can. A missing field is flagged, not refused, with one exception (2026-09-29): a semantic or procedural entry with no source is refused, because a durable claim that cannot point to where it was said is exactly what the record exists to prevent. The door stamps the source from the session's transcript position when the caller names its session. Importance defaults to the layer's charter midpoint; a value outside the band is kept and warned about. The door never infers an assertion's origin.The routing decision is kept in
metadata.routing— whether the layer was chosen by the caller or fell back, and what both routers thought — so routing can be measured later instead of remembered. An unlabelled write is never placed by a router: it lands inworking, flaggedrouting.method: 'fallback', with a receipt warning. Naming the layer is the norm.Content and metadata are digested into their own columns (
sha256,metadata_sha256, the latter over canonical JSON), read back and compared before the write is reported. Every read path —recall,query_layer,semantic_recall— recomputes both on the way out and attachesintegrityandmetadata_integrity:true,false(the row is returned and flagged, never dropped), or'unattested'for rows written before the column existed. Supersession and the correction mark are the only sanctioned mutations of stored metadata, and both re-attest the parent.One receipt shape on both transports:
layer, id, timestamp, verified, sha256, digest_stored, metadata_sha256, metadata_digest_stored, redacted, provenance, source, assertion_origin, importance, routing, warnings[]plus whichever markers apply.
And the record's honesty about its own holes is a query: emet_gaps counts, with the ids
behind each count, unsourced assertions, unattributed inferences, ambiguous attribution by tag
and by session, self-routed writes, unattested rows, digest mismatches, pointer disagreements
against the transcript store, broken supersession, broken correction links, expired-but-live rows, consolidation
candidates, and redacted spans by source. It identifies and never fills — where a source is
knowable the fix is revise_memory with a real pointer; where it is not, the gap stands as a
fact and the count stops growing from that date. emet_initialize carries the counts beside
layer_health.
Topic pages are views, not records. An area is a controlled document, areas/<slug>.md,
checked against templates/AREA.md. It names layers, tags, keywords, document prefixes, an
optional client list, a staleness window (default 30 days), and a cap. Only the owner creates
or edits an area. emet_page computes the page on every request from current records. Every
displayed line cites [mem:<id> · <layer> · <client> · <YYYY-MM-DD>] or [doc:<doc_id>@v<version>].
A line with no source is dropped. Superseded and retired records stay out of the current
sections unless include_history is set, and then only under History. The page is not stored,
not written back, and not returned by recall. emet_page_lint flags contradictions,
superseded-but-current claims, unsourced lines, duplicates, broken links, and long-unconfirmed
statuses. It writes nothing. A Monday emet_initialize carries the weekly counts. STATE.md
stays the hand-kept board; areas/state.md is the selector for a generated view beside it.
The shipped examples are EMET, Health, Learning, Home, and Garden. The owner
writes those files into the store with write_doc. Pages are visible to the owner only.
What can be guaranteed this way: every write attested, attributed, scrubbed, and every absence visible. What cannot be guaranteed without inviting fabrication: every write complete. The store does not promise the latter.
Guardrails & Monorails
The door guards each write. Guardrails & Monorails guards the order of a session's writes.
Guardrails (the floor, the character, the served instructions) bound a field where the AI
moves freely and does its judgment work. The monorail (the session graph,
src/session-graph.js) carries it from one field to the next without asking it to choose:
open, work, record, board, handoff, close. The car can't derail or leave the beam. Where the
flow must fork, a switch at the junction (a small logic unit in EMET's code, tripped only by
its condition, like a transistor; no hosted model, no API) routes the session to the right
guardrail space. The track throws the switch, never the AI. The stations are where the
processing happens, and each station's door opens only when every stop before it has been made.
Switches are designed, not yet built. The server checks the track
on every governed write, so it is the same for any AI on any device. No host hook is needed.
Every skipped step is refused, and the refusal says how to pass. The full practice, the gates and the honest limit
are in docs/GUARDRAILS-AND-MONORAILS.md.
Tools
Thirty-eight tools are registered with sub-keys off. With EMET_SUBKEYS=1, four more (emet_subkey_request, emet_subkey_claim, emet_subkey_revoke, emet_subkey_end_session) and the subkey and session_handle arguments. The names below are every tool the registry registers, both sets together.
accept_nonconformance
corpus_recall
emet_client_approve
emet_error_report
emet_floor
emet_gaps
emet_initialize
emet_invite_create
emet_member_access_create
emet_page
emet_page_lint
emet_pages
emet_session_close
emet_session_open
emet_setup_complete
emet_status
emet_subkey_claim
emet_subkey_end_session
emet_subkey_request
emet_subkey_revoke
emet_transcript_append
list_docs
patch_doc
query_layer
query_transcripts
read_doc
read_doc_history
recall
rename_doc
restore_doc
retire_doc
revise_memory
revise_transcript
save_to_layer
save_transcript
semantic_recall
validate_doc
write_doc
write_doc_abort
write_doc_append
write_doc_begin
write_doc_commitRetained revisions — every document write archives the prior copy; read_doc_history lists
what is retained for a document and returns any retained revision in full, re-hashed against its
stored digest. Retention that nothing could read back was a promise without a witness.
One reader for the second tier — query_transcripts reads the live transcript store and the
legacy exchange archive (rows written by earlier hosts, before the transcript store existed)
together, in one session shape, each result naming the collection it came from. Nothing is
migrated between them.
Document control — validate_doc checks a controlled document against the template that
governs it, and the same check runs inside the write path on every document write, where no
caller can skip it. A record that fails is marked, never rejected: it lands, carries a
nonconformance marker naming what failed, and stays counted at session start until it is
corrected by a later revision or dispositioned with accept_nonconformance. The checks are form
and continuity — sections present, in order and filled; no placeholder left unfilled; every item
on the previous revision still present or carrying a disposition. Whether an answer is true is
not something a machine can check, and this one does not pretend to.
Session start — emet_initialize (start here): fetch every page it names, or pass page: "all"
on a host with no size limit; then emet_session_open with that startup's load_id. Session ids are
dated in the local time zone (EMET_TIMEZONE, default America/New_York); a closed session is
never reopened, so a slug whose id is already closed opens as <id>-2, -3, and the result says so.
After a complete close a session takes exactly one more append, its closing exchange, within
EMET_CLOSE_GRACE_MINUTES (default 5, at most 60) of the close, written into the session's last
part, and is then locked; a retry of it writes nothing. Corrections with revise_transcript stay
allowed but must keep exactly the same exchange numbers.
During the session — emet_transcript_append after every reply, one exchange at a time.
Every write tool also takes session_id and exchange, and returns session_graph.next, the
next stop on the monorail (Guardrails & Monorails).
Session end — emet_session_close. Checks whether the session's work actually reached the
store — transcript saved and intact, continuity documents updated, an episodic entry written —
and reports exactly what is missing. It does not write the artifacts: only the model holds the
session's content, and a tool that generated a plausible-looking summary would be manufacturing
the false continuity the disciplines exist to prevent. emet_initialize returns the same protocol
at session start, which is the only moment early enough to matter.
Setup internals and diagnostics — emet_status (environment, layers, health; probe: true writes and reads back a probe) · emet_setup_complete
Approvals
Every tool declares MCP annotations — readOnlyHint, destructiveHint, idempotentHint,
openWorldHint — in one table in src/annotations.js, which is also the complete statement of
what EMET does to a store. 15 of the 38 tools cannot modify anything; five can replace the
visible content of a document; openWorldHint is false everywhere. The tools reach this
server's own database and nothing else: no filesystem and no shell. The sign-in server fetches
a client's metadata document, and only from a public address it has already checked.
A server that declares nothing is treated as if every call might do anything, so a host that asks before acting asks before every call, including the reads that make up most of a session. These hints let a host stop asking about reads without being told to trust writes. They are hints, not enforcement: what is actually auto-approved is a host-side setting. See docs/PERMISSIONS.md.
Reporting a problem
emet_error_report is owner-only and read-only. It reads the operational error log and returns the full report, a mailto: draft, and a structured email {to, subject, body_text, short_id, version}. EMET does not send mail and does not open a network connection for this tool.
Read the report first. The draft is addressed to EMET_REPORT_EMAIL. When that variable is unset, the address is dreamforgestudio@mail.grokbot.com, the address in src/error-report.js. Set it to your own address to keep reports in house. Set it to an empty string, or to anything other than one plain address, and the tool returns the report and no email.
A calling assistant that has its own email address may pass that structured email to its own email tool. The calling assistant may send this report only after showing the report to its user and getting their OK. EMET will not send it. The code table is docs/ERROR-CODES.md, and the behavior is written up in docs/ERROR-CODES-SPEC.md.
Tests
npm test1,852 checks across 64 suites (the PASS lines npm test prints, counted 2026-10-07). No framework, no database, no
credentials — each suite is a plain node script on one shared harness (tests/harness.js), and
the runner discovers every *.test.js, so npm test runs on a fresh clone. Per-suite counts
are not kept here because they go stale; npm test prints them.
validation.test.js and content_analyzer.test.js began as upstream's own
suites, ported unchanged apart from the import path; every one of upstream's assertions still
stands, and the additions cover EMET's metadata vocabulary and the shared layer list. They are
the original author's assertions about the original author's code, and they are kept passing.
The rest cover this tree. Some are fixtures rather than unit tests — they read the source and
fail on a class of drift: write-path.test.js allows no MongoDB write outside the
sanctioned doors, requires each door to scrub before it hashes, and requires that nothing in
the tree removes from a layer, document or transcript collection; dispatch.test.js
requires the declared tool list and both transports' dispatch switches to be the same set, and
that a list response can carry a caller-facing warning; annotations.test.js requires
every tool to declare its approval hints; atlas-role.test.js requires the database role to
grant no remove on the record. The others test behaviour — among them aleph.test.js
(read-back, digests, signatures, the chain walk), session-graph.test.js (the monorail's
gates and lab results), receipt.test.js, provenance-stamp.test.js, session.test.js,
gaps.test.js and redact.test.js. Their failure
cases matter more than their success cases — a verifier that passes something it should have
caught converts an undetected problem into a confident assurance. layers.test.js asserts
against the store shape that produced the year-long dormant layer, so the check is tested
against the failure it was written for rather than a hypothetical one.
Upstream's index.test.js, decay.test.js and integration.test.js are not carried: they
target the SQLite backend and the temporal decay engine, neither of which exists here. Running
them would produce failures that say nothing about this code.
Benchmarks
EMET's implementation language was evaluated rather than assumed. The same specification was implemented in JavaScript, Python, Go and Rust, deployed identically, and run against live Atlas — with a digest equivalence check proving all four did the same work before any timing was read. JavaScript won, on serial in-process cost, on throughput under concurrency, and on standards provenance as the only candidate carrying an international language standard (ECMA-262 and ISO/IEC 16262).
The exercise's most useful output was not a language choice but a function to optimise: the write-path scrubber was paying nearly full cost on documents containing no secrets, and fixing that saved roughly thirty times what the best available language change could have.
Method, full results, and an explicit account of what was not measured:
docs/BENCHMARKS.md. scripts/redact-bench.mjs measures the scrubber
alone — run it before and after any change to src/redact.js.
Known gaps
Honest list, because the point of this project is that it behaves predictably:
Rows written before 2026-09-05 carry no content digest and rows written before 2026-09-07 carry no metadata digest; reads report them as
'unattested', and they are not backfilled — a digest computed today would attest to today's copy, not to the write.emet_gapscounts the boundary.Entries written before provenance existed keep a null pointer and resolve by timestamp window;
emet_gapscounts them as unsourced. They are not backfilled, for the reason given under Provenance.Two content routers are carried from upstream (a substring keyword router and a content analyser). Measured against a 1,175-row corpus both agree with the stored layer well under half the time (41% and 36%), so neither places entries: an unlabelled write lands in
working, flagged, with both opinions recorded inrouting(keyword_layer,analyzer_layer). Retuning them into something fit to route is possible with those numbers as the baseline; it is not scheduled.consolidation_candidatesinemet_gapsis tag overlap, not semantic similarity.The monorail (session graph) refuses every skipped step (enforce only since 2026-10-03; there is no report mode or off switch). Its turn coverage is only as strong as the exchange numbers hosts report, and it never sees the reply text. See Guardrails & Monorails.
A scheduled job that writes without opening a session is refused by the session-order check (gate
no_session) until it opens a session with its startup'sload_idand passes thesession_id. Acloud-scheduled-prefix is not a registered tag. Only an exact tag inEMET_SOURCE_TAGSis accepted.emet_gapskeeps counting rows already written under an old tag as ambiguous attribution instead of rewriting history.save_transcript's description does not state that it stores content verbatim; the implementation does.No export / import / restore-and-compare yet.
These collections are not prefixed:
documents,documents_history,transcripts,exchanges,persons,invites,close_attempts,error_log,error_log_summary, and_emet_verify. One database holds one instance. Run separate databases rather than separate prefixes if you want separate memories. One collaborative project is one instance (one database, one deploy, one passphrase). See docs/SECURITY-AT-SCALE.md.Dynamic Client Registration is still served beside Client ID Metadata Documents; the MCP specification's deprecation window closes around 2027-07. It is scheduled to come off on 2027-06-01.
Delegated client sub-keys stay off unless setup is told that more than one bot or AI will use the memory. A hosted server does not write a pepper into its container. A stamp shows that an approved key was presented, not which program held it. See docs/SUBKEYS.md.
Origin
EMET was built by Dreamforge Studio LLC from a neurodivergent user’s own need for an AI assistant that remembers. The word coined for that is neurendipity: neurodivergent and serendipity.
It is designed first for neurodivergent users, and it works for anyone.
License and access
EMET is free and open source under the MIT License (see LICENSE). No account, key or payment is required to run it.
Authorship of the commit history, including a correction recorded as an addition
rather than a rewrite: docs/AUTHORSHIP.md.
MIT. See LICENSE — both the original C.I.P.S. LLC notice and the Dreamforge Studio LLC notice
must travel with any copy.
Available Tools
38 toolsaccept_nonconformanceA
Record the written disposition for a nonconformance that will not be corrected. A marker is never cleared silently: it leaves either because a later revision passes, or because someone accepts it in writing here. The marker is RETAINED with the acceptance beside it, and the acceptance covers only the revision it names - the next write is validated fresh, and accepted markers stay counted at session start, separately from open ones. The reason must be at least 10 characters: it is what an audit reads later.
Inputs: doc_id (required), reason (required), source, exchange, +2 more.
corpus_recallARead-onlyIdempotent
Semantic search over an optional supplementary knowledge corpus that the user has loaded separately from memory. Returns nothing unless a corpus has been populated; this is not where session memory lives.
Inputs: query (required), limit, corpus.
emet_client_approveADestructive
Approve or deny a pending client tag, or prepare a new writer. decision prepare drafts a writer request: client, claimed tag, door (member or guest), reason, and correlation_id. The hub login prepares that draft. The server validates it. Validation is a check and is not approval. The owner decides a new writer on /owner/chooser with the owner session. No AI grants a writer, including the hub login and the retired owl account. The owner login may still approve or deny a pending client tag. Pending client tags are listed in emet_initialize and emet_status as client_approvals.
Inputs: tag (required), decision (required), as, door, +5 more.
emet_error_reportARead-onlyIdempotent
Read the operational error log and show a report the owner can send on. Owner only. Read-only: it writes nothing and sends nothing. EMET has no mail sender and opens no network connection for this tool. The result is the full report, then a mailto link, then a structured email {to, subject, body_text, short_id, version} a calling assistant can pass to its own email tool. The calling assistant may send this report only after showing the report to its user and getting their OK.
Inputs: codes, limit, since, correlation_id.
emet_floorARead-onlyIdempotent
Read the floor: the standing description of how this assistant engages with the person using it. It ships in the server code, so setup cannot overwrite it and no install can lose it - the character document holds the user's modifiers on top of it. emet_initialize already returns the whole floor at session start; call this to read it again without re-running initialize. Use compact: true for the short form partway through a long session, when the start of the conversation is far behind. Pass gem to read one installed GEM's floor; reading does not turn that GEM on. Read-only, and re-reading is not the same as being bound by it.
Inputs: gem, compact, section.
emet_gapsARead-onlyIdempotent
The record's honesty about its own holes, as a query. Read-only; identifies and never fills. Counts, with the ids behind them, for each gap class: unsourced assertions, unattributed inferences, ambiguous attribution (by tag and by session), uncertain routing, unattestable rows (pre-2026-09-05 boundary), digest mismatches (the alarm - expect zero), pointer disagreements against the transcript store, broken supersession, expired-but-live rows, consolidation candidates (tag families; a list for a person), and redacted spans by source. Call it when asked how trustworthy the record is, before a consolidation pass, or after any migration. Closing a gap is a person's decision: revise_memory with a real derived_from where the source is knowable; otherwise the gap stands as a fact.
Inputs: layer, limit, since.
emet_initializeAIdempotent
START HERE. Call this FIRST in every session, before answering anything that might have prior context, and always when the user opens with 'initialize', 'start', 'begin', 'hello' or similar. It is the only setup step a user should ever have to know about. A large startup comes in pages: read page_notice first and call again with the page it names until the last page, before replying. If this memory store is new it returns a short interview to run conversationally; if it is established it returns who you are, how you speak (character, when the store keeps one - authoritative on voice for the whole session), who you are serving, and where things were left. The user never needs to know which case applied.
Inputs: page, source, load_id, recent_limit.
emet_invite_createADestructive
EMET Guest Access: create a one-time code for a guest. They paste it on the connect screen instead of the passphrase. Default access is read-only. Only the owner can create a guest code. EMET Member Access is a different door.
Inputs: display_name (required), days, scopes, source.
emet_member_access_createADestructive
EMET Member Access: create a one-time code for a new person with read and write access. They paste it on the connect screen instead of the passphrase. This is not EMET Guest Access, and it never makes them the owner. Only the owner can create it. Off unless EMET_MEMBER_ACCESS=1.
Inputs: display_name (required), days, source.
emet_pageARead-onlyIdempotent
Read one compiled topic page for an area slug (areas/.md). A page is a view of current records. It is not a record: this tool writes nothing, stores nothing, and the result is never written back and is not returned by recall. Every displayed line cites its source as [mem: · · · ] or [doc:<doc_id>@v]. A line with no source is dropped. Superseded and retired records stay out of the current sections; pass include_history true to show them under History only. A line is marked stale when its source has not been confirmed or revised within the area's staleness window (default 30 days; the area document may set its own). Owner only. Computed on every call, so cache_hit is false.
Inputs: area (required), as_of, include_history.
emet_page_lintARead-onlyIdempotent
Flag problems in topic pages and the records they read. Read-only: it never edits a record. Findings cover contradictions (two current records that share a subject and disagree), superseded or retired records still claimed as current, lines with no source, duplicates, broken links, and statuses unconfirmed longer than the area's staleness window. It builds on the emet_gaps classifiers. A fix is a person's revise_memory, retire_doc, or accept_nonconformance. Owner only. Omit area to lint every area.
Inputs: area.
emet_pagesARead-onlyIdempotent
List current area documents. For each area: line count, stale count, and the time of the newest source the page read. Read-only. Owner only. Computed on every call. The page body is not stored.
Inputs: no named parameters.
emet_session_closeA
Call this when the session is ending - the user says goodbye, asks you to wrap up, mentions restarting or opening a new session, or you are about to run out of room. An acknowledgement of the turn just completed - thanks, great, perfect - is not a session end; if it is ambiguous, ask rather than close. Checks whether this session's work has actually been written to the store and reports exactly what is missing. It does not write anything itself. RECEIPTS ARE REQUIRED: pass receipts naming what you wrote and read back for each close step - working documents, the episodic session record id, the board and its version, the transcript part ids and highest exchange index as query_transcripts returned them, and the handoff version (written last). Each receipt is compared with the store; omitted or mismatched receipts, a handoff that was not the last write, or a transcript no layer entry cites (derived_from) return state 'blocked'. Each missing line carries a scope: touch only what it names. THREE blocked closes on one session return state 'escalate': stop retrying, say the speak lines, and hand the user the list - the counter does not reset on a changed receipt, only with a new session. Say every line of the returned speak to the user, in order - a wrap that leaves it out is a failed close. A records/ session disposition is not a receipt and does not make this call complete. Pass carry_forward only for an old open session whose HANDOFF and STATE a later session already advanced. The owner door, or the credential that wrote the session, cites the current conforming records/ disposition (CARRIED_FORWARD, SUPERSEDED_BY_LATER_SESSION, or ABANDONED_NO_TRANSCRIPT) and those later versions. RETAINED_OPEN_CRITICAL stays open. A declared source is not authority. Transcripts are not deleted. A refused carry_forward is not counted. A receipt close blocked only because a later session holds HANDOFF or STATE stays blocked and is not counted. A same-session close is unchanged. Never tell the user their session is saved unless this returns state 'complete'.
Inputs: source, exchange, receipts, session_id, +3 more.
emet_session_openA
Open a transcript session. Returns session_id, dated in the configured local time zone (EMET_TIMEZONE, default America/New_York). A slug that already begins with YYYY-MM-DD_ (month 01-12, day 01-31) is not dated again, even when that date is not the local day. A slug whose id is already CLOSED is never reopened: the session opens as -2, -3, ... and the result's notice says so. Pass load_id from your startup pages (startup_page.load_id on every emet_initialize page) so the startup page check runs on your own startup; an open without load_id, or with a page of that startup never fetched, is refused (the refusal says how to pass). After every reply, call emet_transcript_append with that id and the one exchange that just happened. Do not dump the whole chat at close.
Inputs: slug, load_id.
emet_setup_completeADestructive
First-time setup, the owner's only: record the user's interview answers as bootstrap/IDENTITY.md, bootstrap/CHARACTER.md and bootstrap/USER.md and as an identity-layer entry, and create the owner person. Every write is read-back verified. Refused under a bot tag. On a store that is already set up it is refused unless reissue is true (the owner's explicit word): a re-run writes new versions of the user's identity documents; prior versions are archived, never destroyed. answers.more_than_one_bot is optional. Absent or no leaves sub-keys off. yes writes EMET_SUBKEYS=1, a generated pepper and EMET_SUBKEY_PEPPER_VERSION=1 into .env only when that file is the config source, after the store writes succeed, and does not turn the flag on in this process. A hosted server refuses yes and returns the three variables to set, then redeploy. See docs/SUBKEYS.md. answers.bot_team_backup is optional. Yes or no, in the user's words, the same way as more_than_one_bot. Yes and Yes. record the flag. yes is the recommended choice. Absent or no leaves bot-team backup off. Anything else, including a non-string, is refused before a write. Setup does not copy prompts or settings.
Inputs: answers (required), source, reissue.
emet_statusAIdempotent
Diagnostic in one call (replaces emet_setup_status, get_status and emet_verify_connection, 2026-09-27). Reports environment, database, collections, vector index, whether identity and user documents exist, and per-layer counts and health. Pass probe: true to also prove the write path - connect, write a probe document, read the same value back, remove it; a read alone cannot reveal a broken write path. Pass session_id to read that session: session.state is open, closed, or absent, or unreadable when the session row cannot be read (the rest of the status still returns, and the asked id is not echoed). A part id is read as its base session. Prefer emet_initialize for a normal session start. Also reports checkpoint on every call: due when an open session's last verbatim save, or the open itself when no transcript is saved, is at least 24 hours old. A session covered by a current conforming records/ disposition (templates/SESSIONDISPOSITION.md) is not listed as checkpoint-due. A row that names an inserted_id dispositions that transcript only and does not close the session. The disposition is not a receipt. Save that verbatim text with emet_transcript_append or save_transcript, under the open session or the daily YYYY-MM-DD_chat-daily session. emet_session_close cites the saved parts. A store that cannot be read sets checkpoint.unread and does not claim the save is current.
Inputs: probe, source, session_id.
emet_transcript_appendB
Append ONE exchange to the session transcript. Call after every reply. Idempotent on exchange_index. Rolls to a new part after 8 exchanges. After a complete close the session takes exactly ONE more append - its closing exchange, numbered next, within EMET_CLOSE_GRACE_MINUTES (default 5) of the close; it is written into the session's last part whatever session_id it names, and the result's closing_exchange says it was accepted and that the session is now locked. A retry of that exchange number is answered as already saved and writes nothing. exchange_index, when given, must be a whole number of 1 or more (a number or its text). Any other append to a closed session is refused and nothing is written; that exchange belongs in the next session you open the usual way. THE FIRST SUCCESSFUL APPEND OF A SESSION IS CHECKED, at whatever exchange_index opens the transcript or becomes the lowest stored index. A refused exchange 1 does not let a higher index start the transcript. Its assistant_message must carry the measured machine line - a machine name from the install notes plus the clock reading, as the shell returned them - or the words no local shell MCP. Without one of those the append is refused and nothing is written.
Inputs: session_id (required), user_message (required), assistant_message (required), source, +3 more.
list_docsARead-onlyIdempotent
List continuity documents (metadata only; optional doc_id prefix filter, e.g. 'threads/'). Current documents come first. Retired documents stay in the list, marked with retired_at and, when a rename replaced them, what replaced them.
Inputs: prefix, include_retired.
patch_docADestructive
Replace one exact substring in a document (str_replace semantics) without resending the whole file. THE PREFERRED WAY TO MAKE SMALL EDITS to large docs like STATE.md. old_str must match EXACTLY ONCE - zero or multiple matches are rejected rather than guessed. Pass new_str as an empty string to delete. Same versioning, archiving, and sha256 read-back as write_doc.
Inputs: doc_id (required), reason (required), edits, origin, +7 more.
query_layerCRead-onlyIdempotent
Query a specific memory layer with structured filters
Inputs: layer (required), options.
query_transcriptsARead-onlyIdempotent
Retrieve session transcripts - the second tier, word for word. Reads the live store written by save_transcript AND the legacy archive (exchanges written by earlier hosts, June 2025 to June 2026), grouped into the same session shape; every result carries source naming the collection it came from. Nothing is migrated between them. Use it when a layer entry is relevant but thin: the transcript around its timestamp holds the depth the layer compressed out.
Inputs: timestamp_end (required), timestamp_start (required), limit, session_id.
read_docARead-onlyIdempotent
Read a continuity document from the versioned document store. A document longer than one page (18,000 UTF-8 bytes by default) comes back in pages: the result then carries page with next_offset - call again with that offset (and expected_version set to the first page's version) until next_offset is null, and do not act on a document you have only part of. If the document changes between pages the read is refused: restart from offset 0. sha256 and size (characters; size_bytes in UTF-8 bytes) always describe the WHOLE document.
Inputs: doc_id (required), limit, offset, expected_sha256, +1 more.
read_doc_historyARead-onlyIdempotent
Read a RETAINED revision of a document, or list the revisions retained for it. Every write archives the prior copy (nothing is deleted); this is the reader for that archive. Without a version: the list of retained revisions with their digests and dates. With a version: that revision's full content, re-hashed against its stored digest. Read-only. Use it for an audit question - what did this document say at version N - or to compare a document with what it replaced.
Inputs: doc_id (required), version.
recallARead-onlyIdempotent
Search memories by keyword. Ranked by how many of your words match, then by importance. Current entries come first in every order. Pass order: 'latest' for time order. A standalone latest, newest, or most recent, together with other words, also asks for time order: it reorders those matches and does not change which rows match. A hyphenated word such as latest-budget, a negated 'not the latest', and a bare 'latest' are ordinary keywords. Expired and superseded entries stay in the result, marked with their end date and what replaced them. Pass history: true to read ended entries when current ones fill the limit.
Inputs: query (required), layer, limit, order, +1 more.
rename_docA
Reissue a continuity document under a new doc_id. The destination is written first through the normal write path (same redaction, digest, versioning and sha256 read-back), and only then is the old id marked obsolete with retire_doc. NOTHING IS DELETED: the old id keeps its content and stays readable at its own id, flagged retired with the reason 'Reissued as <new_id>'. list_docs keeps it after the current documents and names the new id in replaced_by. No tombstone document is needed, because the retired original IS the tombstone and it still carries the real content. Refuses if the destination already exists, because a rename onto an occupied id is a merge decision and merges are not guessed.
Inputs: new_id (required), old_id (required), reason (required), source, +3 more.
restore_docADestructive
Write a retained revision back as the current document. The retained row is copied through the normal write path, with a reason. Nothing is deleted.
Inputs: doc_id (required), reason (required), source (required), version (required), +2 more.
retire_docAIdempotent
Mark a continuity document OBSOLETE. Nothing is deleted: the document keeps its id, its full content, its version and its digest, and read_doc still returns it, flagged retired, with the reason. list_docs and the startup scan keep it too, after the current documents, with retired_at and what replaced it. A retired drop is not an unhandled drop. This is document control as ISO 7.5.3 describes it - issue the revision, mark the prior copy obsolete, retain it - and it is the document-store counterpart of revise_memory superseding a layer entry. THE STORE HAS NO DELETE, BY DESIGN. Use for genuine litter: tombstones, merged staging documents, test scratch. Reversible: write_doc on the same id brings it back into the working view.
Inputs: doc_id (required), reason (required), source, exchange, +2 more.
revise_memoryA
Supersede an existing entry with a revised one (supersession, not mutation). Creates a NEW entry carrying metadata.supersedes=<target_id> and marks the target with superseded_by and superseded_at. The old entry stays readable: it is not hidden and is_live is not cleared. Recall, query_layer and semantic_recall return it marked with that end date and the id of the new entry. The current entry is listed first. Episodic revision is prohibited - events are immutable.
Inputs: layer (required), content (required), target_id (required), exchange, +2 more.
revise_transcriptA
Supersede a stored transcript part with a corrected one. Nothing is edited or deleted: a NEW document is written under the same session_id with an incremented revision and a pointer to its parent, and the parent is marked superseded. Use when a saved part has a mispaired, missing or wrong exchange. The reason parameter is required - an unexplained correction is a silent rewrite. To ADD a new part, use save_transcript instead. Allowed on a closed session (a correction deletes nothing), but there a revision may only correct the exchanges the part already holds - never add new ones - and must carry exactly the same exchange numbers (none dropped or repeated; numbers sent as text are stored as numbers).
Inputs: reason (required), exchanges (required), session_id (required), source, +4 more.
save_to_layerA
Save memory to a specific layer with full control over metadata. PASS session_id - your transcript session from emet_session_open - on every save made inside a session: the server stamps derived_from with the exchange in progress. Semantic and procedural entries are REFUSED without a source (session_id, or metadata.derived_from); nothing is written when refused.
Inputs: layer (required), content (required), exchange, metadata, +1 more.
save_transcriptA
FALLBACK. The primary path is emet_session_open then emet_transcript_append after every reply; use this only where a host cannot append per reply. Saves the full word-for-word dialog of a session - full transcripts only, no summaries. Pass exchanges in the call. The server does not read a file. Refused for a session that was closed complete.
Inputs: exchanges (required), session_id (required), session_start (required), source, +3 more.
semantic_recallARead-onlyIdempotent
Semantic (meaning-based) memory search across all six memory layers via Atlas Vector Search autoEmbed. Finds conceptually related memories even without keyword overlap. Complements keyword-based recall/query_layer.
Inputs: query (required), layer, limit, history.
validate_docARead-onlyIdempotent
Check a controlled document against the template that governs it, WITHOUT writing anything. The same check the write path runs on every document write - this is the freestanding form, for auditing records written before validation existed, for counting what adoption will mark before it marks anything, and for checking new content before it is stored. Pass doc_id to check a stored document (the previous revision is pulled from the archive so the carry-forward check runs). Pass content, with template_id or a doc_id the map covers, to check text that is not stored. Checks FORM and CONTINUITY only: sections present, in order and filled; no placeholder left unfilled; NOT COMPLETED carrying a reason; a board's counts matching its rows; every row on the previous revision still present or dispositioned. It cannot check whether an answer is true, or whether a 'none' states its scope honestly - those stay with the author and the reader.
Inputs: doc_id, content, template_id.
write_docADestructive
Write or update a continuity document in the document store (versioned, prior copy archived to documents_history and marked obsolete, sha256 read-back verified). RECORDS - the handoff (HANDOFF.md) and any id in EMET_RECORD_DOCS - are superseded, never amended: patch_doc is refused on them, and a new revision is written here WHOLE with supersedes set to the version currently in force (ISO 9001 7.5.3 / 13485 4.2.5).
Inputs: doc_id (required), content (required), reason, source, +4 more.
write_doc_abortAIdempotent
Drop an open stage. The current document is unchanged. Aborting a stage that is already aborted reports that abort and writes nothing.
Inputs: stage_id (required), source, exchange, session_id, +1 more.
write_doc_appendAIdempotent
Append the next ordered chunk of an open stage. part starts at 1 and increases by one. The same part with the same bytes is a no-op. A different byte string, a skipped part, or a chunk over 16000 characters is refused and the current document is unchanged.
Inputs: part (required), chunk (required), stage_id (required), source, +3 more.
write_doc_beginA
Open a staged write when a document will not fit in one write_doc argument. The stage is not a document and does not change the current revision. Send each part with write_doc_append, then write_doc_commit. A record (HANDOFF.md and any id in EMET_RECORD_DOCS) still needs supersedes and reason; commit writes one whole revision through write_doc. Limits: 16000 characters per part, 128 parts, 2000000 characters total, 30 minutes from begin, 4 open stages per writer. Same source, session, and writer stamp as write_doc.
Inputs: doc_id (required), reason, source, exchange, +3 more.
write_doc_commitADestructiveIdempotent
Assemble an open stage, check part_count and the sha256 of the exact assembled text (the concatenation of the parts in order, before this server redacts it), then write one revision through write_doc. A mismatch or a write_doc refusal leaves the current document unchanged and the stage open. A second commit of the same sha256 returns the first receipt and does not write another revision. A record is still one whole revision: it is superseded, never patched or appended.
Inputs: doc_id (required), sha256 (required), stage_id (required), part_count (required), +6 more.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 38 tools
Most tools target a clearly distinct resource and verb, and the long descriptions actively disambiguate the risky pairs (keyword recall vs. semantic_recall vs. query_layer vs. corpus_recall; save_transcript vs. emet_transcript_append vs. revise_transcript). The remaining soft spots are the three document-listing surfaces (emet_pages, list_docs, emet_page) and the four recall entry points, which an agent could plausibly pick wrongly on first contact, though descriptions do provide rescue.
Everything is snake_case and mostly verb_noun readable (write_doc, read_doc, revise_memory, query_transcripts), so there is no chaotic camelCase mixing. But the surface is split into an emet_* prefixed family (emet_status, emet_session_open, emet_floor, emet_gaps) and an unprefixed family (recall, save_to_layer, list_docs, patch_doc) with no obvious rule for which gets the prefix, and verbs fragment across recall/query/semantic_recall/corpus_recall for the same action.
At 38 tools this is well past a comfortable surface and forces an agent to reason over a large catalog before acting. The scope genuinely spans several domains (memory layers, transcripts, versioned documents, access control, diagnostics/audit), so the count is not padding, but several entries are niche or one-shot (emet_error_report, accept_nonconformance, write_doc_abort, restore_doc) and could be consolidated into fewer parameterized tools.
Coverage is unusually deep: full document lifecycle (write, staged write, patch, rename, retire, restore, history, validate, nonconformance acceptance), transcript open/append/revise/query/close, four memory read paths plus save and supersession-based revision, and setup/access/diagnostics. The only real gaps are around access management (create guest and member codes, but no list or revoke for either) and the deliberately absent hard delete, which is documented as a design decision rather than an omission.
Maintenance
Related MCP Connectors
Persistent, inspectable memory for AI agents with lineage, correction, and a hosted MCP endpoint.
Verified memory for AI agents. Signed assertions, billing attestation, session continuity.
Governed local-first memory and continuity for AI agents — signed receipts, optional hosted lane.
Hosted agent memory with provenance, contradiction surfacing, and snapshot rollback.
Related MCP Servers
- AlicenseNot gradedqualityCmaintenanceEnables agents to read and write a durable, append-only memory with verified provenance, supporting search, record capture, and context preparation across sessions and machines.1MIT
- AlicenseNot gradedqualityBmaintenanceProvides AI agents a shared long-term memory layer with evidence-backed, auditable claims, enabling persistent, explainable, and conflict-aware recall across sessions.8MIT
- AlicenseNot gradedqualityCmaintenanceEnables AI agents to store and recall an append-only, hash-chained memory with citation-backed semantic search, fact verification, contradiction detection, and replay/audit capabilities through local MCP tools.1AGPL 3.0
- AlicenseNot gradedqualityBmaintenanceEnables AI agents to maintain persistent memory across sessions with verifiable source receipts, supporting explicit remember, recall, inspect, correct, and forget operations.52Apache 2.0