Saga · Memory · built for compliance and incident-response teams
Prove years later what your AI knew, and what it did.
Every receipt and memory your AI creates lives here, encrypted, portable across every model you switch to, still provable years later.
Saga is your context, persona, and skills, carried across Claude, GPT, Gemini, a local model, or whatever you pick up next. The model is disposable; the memory is yours. And unlike every other memory layer, every record is signed and hash-chained today. External anchoring to Bitcoin (OpenTimestamps) and sigstore Rekor is planned for Q4 2026, so verification won't depend on SynOI's continued existence.
Saga is built on SynOI Vault, the append-only, cryptographically-signed substrate detailed below. Same model-portable memory also cuts your provider bill via layered cache, and cost savings come free with the memory.
Agents have an accountability problem.
Vector databases solve retrieval. Context engines solve freshness. Both are real problems, both have good products.
Neither solves accountability: proving what your agent did, when, with what evidence, under whose authority. That problem isn't a database problem. It's a record-keeping problem. And record-keeping has a 4,000-year-old answer: append-only ledgers with cryptographic integrity and external trust anchors.
SynOI Vault is the record-keeping layer for AI agents. Memory is a feature; verifiability is the product.
Two tiers. One protocol.
Memory tier
The cache
Bounded. LRU-evicted. Holds working-set CDROs, L1/L2/L3 LLM response cache, hot AI memory. When an agent asks a question someone else asked yesterday, the answer comes from here in milliseconds: no upstream call, no token cost.
- ·L1 exact match (bit-identical request)
- ·L2 structural match (same question, drift in date / CWD / context)
- ·L3 semantic match (same question, different wording): a per-tenant HNSW vector index (cosine, 384-dim) on the default SQLite backend. A linear cosine scan survives only as the edge-case fallback, below the index threshold or past the per-tenant vector cap. An opt-in Resonance re-ranker can refine the same candidate set for tenants who enable it.
Canonical tier
The audit trail
Unbounded. Append-only. Hash-chained. Holds Decision Receipts, Evidence Journal entries, signed skills, signed packages, and long-term agent memory. Once a record lands here it's immutable; supersession is the only update model.
- ·Every record signed Ed25519 + ML-DSA-65 hybrid
- ·Content-addressed via OID (sha256 of canonical payload)
- ·External anchoring to OpenTimestamps (Bitcoin) + sigstore Rekor: planned, Q4 2026
- ·Point-in-time view reconstructable via the supersession chain: what did the agent know at 14:32? (a dedicated as-of query API is on the roadmap)
One catalog. One physical store. Two semantic tiers distinguished by a role tag. Migrate hot records from memory to canonical when they earn permanence; cache layers can be wiped without losing audit history.
What you can do with Vault that you can't do with a memory layer.
The agent memory category is filling up. Pinecone, Weaviate, Redis Iris, MongoDB Atlas Vector: all good products for storing and retrieving vectors. None of them produce records you can independently verify offline.
Prove what the agent did.
Every Decision Receipt is signed at issuance. Anyone with the public verification key can replay the canonical payload, recompute the hash, and verify the signature, without contacting SynOI. Receipt verification is an offline operation. The audit trail survives our company going away.
Anchor to a trust root we don't control (planned, Q4 2026).
Periodic Merkle-root anchoring to OpenTimestamps (Bitcoin block inclusion) and sigstore Rekor (public transparency log) is planned for Q4 2026, so the history of records becomes verifiable against systems we have no power over. Today, every record is already signed: an attacker who compromises SynOI cannot produce a valid signature over an altered record.
Encrypted at rest and compressed automatically.
AES-256-GCM per record, with a per-record IV and a 16-byte auth tag bound to the record's OID and tenant, so a row spliced into the wrong place fails decryption on read. Records also compress with zstd, cutting cache disk size 3-5x on typical LLM responses.
Track supersession instead of overwriting.
Append-only by design. When a record gets updated, the new version supersedes the old via explicit reference; the old version remains queryable forever. Critical for compliance (HIPAA, GDPR right-of-access, SOX) and for forensic incident response.
Content-address everything.
Two installs of Vault that hold the same record produce the same OID. Federation is trivial. Deduplication is automatic. Cross-tenant intel queries don't require synchronizing keys; just exchange OIDs. The protocol works across organizational boundaries because the identity is the content.
Pluggable storage backend.
Default is SQLite: zero dependencies, works on a laptop. Production deployments can swap in Redis, PostgreSQL, DynamoDB, or OpenSearch. The governance layer (signing, supersession, hash chain) is independent of where the bytes live. If you already run Redis, you can use Vault on top without operating a second database.
Verify cross-vendor without a centralized authority.
The SRAID protocols are open under CC0. Any vendor can implement them. Two agents from different companies can exchange signed receipts, verify each other's history, and federate intelligence, without either side controlling the trust root. There is no equivalent in any proprietary memory layer.
How it compares.
Vault is in the same shelf as agent memory products from Pinecone, Weaviate, Redis, MongoDB Atlas Vector. The shelf is filling up. Here's where Vault stands.
| Property | Generic memory layer | SynOI Vault |
|---|---|---|
| Vector search | Yes | Per-tenant HNSW index (cosine); linear scan is the fallback below the index threshold |
| Semantic caching | Yes | Yes (L1 + L2 + L3 layered) |
| Cryptographic signing on every record | No | Ed25519 + ML-DSA-65 hybrid |
| Append-only audit semantics | No: mutable | Canonical tier append-only by design |
| External trust anchor | None | OpenTimestamps (Bitcoin) + sigstore Rekor (planned, Q4 2026) |
| Content-addressed identity | Key-value or namespace | OID = sha256(canonical payload) |
| Multi-tenant per process | Varies | Native: one Vault, N tenants |
| Survives vendor shutdown | Records become inaccessible | Verification needs only the public key, not SynOI |
| Open spec | Proprietary | SRAID under CC0 |
| Self-host | Varies | Free, npm package, runs anywhere Node runs |
Vault is not faster than Redis. Not bigger than Pinecone. Not cheaper at scale than DynamoDB. We make exactly one promise the rest don't: the record holds up.If you need that, you need Vault. If you don't, use what fits.
Pick Vault when…
You operate in a regulated industry.
Healthcare under HIPAA, finance under SOX/PCI, government, life sciences. Auditors want signed evidence, not vendor screenshots.
You ship a SaaS that other businesses audit you on.
SOC 2 Type II, ISO 27001, FedRAMP. Vault produces compliance evidence as an artifact of normal operation, not as a periodic export project.
Your agent could cause real harm.
Financial transactions. Healthcare decisions. Industrial control. Legal advice. You need the ability to say, after the fact, what the agent did and under whose authority.
You need to outlive your vendor.
Many vendors. Many platforms. None of them are guaranteed to be around in five years. Vault's signed receipts verify with the public key alone, independent of SynOI. External anchoring (Bitcoin + Rekor) is planned for Q4 2026 for tamper-evidence beyond our own infrastructure.
You want open over locked-in.
The SRAID protocols are CC0. You can fork them. You can implement your own Vault. You can compete with us. We're comfortable with that because the platform we run, not the protocol we publish, is the moat.
You're integrating multiple AI vendors.
One agent talks to another. They cross organizational boundaries. They need to verify each other's claims. Vault's content-addressed federation works without a central trust authority.
The free version is the same software.
Saga ships as an npm package inside SynOI Gateway, on the Vault substrate. Free tier runs the same memory and the same signing today; external anchoring lands for every tier together in Q4 2026. Paid tiers add operational services (hosted, multi-machine sync, cross-tenant intel), not new code.