Most agent memory retrieves text. Maat preserves the evidence behind belief: what the agent knew, when it knew it, why it trusted it, and who was allowed to see it. Every belief is derived from an append-only, hash-chained event log.
When an agent acts on a stale fact, leaks restricted context, or contradicts itself, retrieval can find the bad answer but not reconstruct the belief behind it. Maat preserves what the agent believed, when it believed it, why, and under whose authority. The evidence survives every update.
Reconstruct what was valid in the world and what the system believed at the time. Valid time and audit time stay independent.
Trace every belief to its source and change events. If access is blocked, return a verdict without leaking the content.
Commit the log with a BLAKE3 chain, Merkle root, and Ed25519 checkpoint. A changed or missing event breaks the proof.
Principal, scope, and namespace travel with events. Reads, proofs, and derived beliefs preserve those boundaries.
Contradictions stay visible and attributed until an eligible reviewer records a rationale-backed decision. No silent last-writer-wins.
Export a signed, permission-filtered bundle that another party can verify offline without the store or Maat runtime.
Every write adds an attributed event to a BLAKE3 hash-chained log. Updates preserve the prior state instead of replacing its evidence.
Events produce beliefs with independent valid-time and audit-time intervals. The current answer can change without erasing what the system believed before.
A Merkle root commits to every event in the prefix. An Ed25519 signature lets another party verify the same history independently.
You can bolt retrieval onto anything. You can't bolt on a history that was never recorded.
| The question an operator actually asks | Recall-only memory | Maat |
|---|---|---|
| What did it believe last Tuesday? | ~latest snapshot or ad hoc logs | ✓as-of across both time axes |
| Why does it believe this? | ~metadata or a source pointer | ✓exact event chain per belief |
| Has the record been changed? | ~trust the database and operator | ✓independent hash and signature proof |
| Is this agent allowed to see it? | ~filter at the application layer | ✓authority preserved through provenance |
| Two agents disagree. Now what? | ~overwrite or merge heuristics | ✓visible conflict and governed decision |
| Can another party verify it? | ~export the system's own report | ✓verify the proof offline |
The distinction is architectural. Retrieval finds content. Maat's event-backed substrate preserves the history, authority, and cryptographic evidence needed to defend a belief after it changes.
An integrity dashboard is still the system vouching for itself. A Maat proof carries the material needed to recompute the chain, rebuild the Merkle root, and check the signature offline.
Visible events carry authenticated content. Withheld events keep their position in the proof without revealing restricted content.
The bundle carries event hash inputs, the Merkle path, and the checkpoint's signed bytes. Verification does not require the live store.
Recompute the chain, rebuild the Merkle root, and check the signature. Changed content, missing events, and forged signatures fail distinct checks.
The concept reduces agent memory to five understandable actions. Each one operates on the same history instead of hiding another memory store behind the interface.
Write a durable fact. A new value supersedes the old one and preserves both in history.
Permission-filtered retrieval. Blocked beliefs return content-free existence stubs.
The provenance chain behind a belief, or the block verdict if you can't see it.
Export a portable, independently-verifiable proof bundle.
Check bundle content, chain links, Merkle paths, signatures, and store identity when pinned.
Maat is an active product exploration into verifiable, governed agent memory. This site shares the product idea, architecture, and direction while the work continues.