Memory that can testify.
Cortex records what the system did and lets anyone verify it later. Canonical truth lives in append-only spine records anchored by Epoch Roots; retrieval indexes are disposable derivatives. Replay is read-only. Missing anchors fail closed.
Proof-oriented capabilities.
- Provides Evidentiary Memory, also called Verifiable Memory: every canonical fact is recorded so it can be independently checked, not merely asserted.
- Separates canonical truth from disposable retrieval surfaces. The vector index is derivative. The spine record store is authoritative.
- Orders retrieval with Gravitational Recall, where gravity weights are recall ordering only and never gate canonical truth.
- Anchors memory state with Epoch Roots so any later claim can be verified against a fixed root, with read-only replay and counterfactual recall for inspection.
- Fails closed on missing anchors and emits governed Evidence Packs with tamper-detectable manifests instead of unverifiable assertions.
Boundary protected.
- Cortex is not a vector database, RAG wrapper, or chat history cache.
- Cortex does not decide whether an action may execute.
- Cortex does not perform runtime execution governance or turn retrieval output into authority.
Memory is evidence. Retrieval is disposable. Permission lives elsewhere.
Cortex records, reconstructs, and verifies canonical memory while Runtime remains the execution boundary and Collective remains the cognition layer. Vector databases are semantic indexes. They are not memory. Gravity orders recall. It never gates canonical truth. Spine records are permanent; gravity weights are recall ordering only.
Receives, outputs, never.
Memory claims require proof.
Vector databases are not memory. They are semantic indexes.
Cortex separates canonical memory truth from disposable retrieval surfaces.
Gravity orders recall. It never gates canonical truth.
Do not trust the memory layer. Verify it.
One command. Seven proof families. Deterministic output.
Single verify-all export for the full Cortex proof spine.
Composes deterministic memory, tenant isolation, replay durability, authority/index separation, shard identity, decay/reinforcement, and governed signing evidence.
The bundle is content-addressed by deterministic SHA-256 Merkle root.
CI can diff repeated outputs and reject non-deterministic proof generation.
The proof bundle is portable, inspectable, CI-gated, and ready for downstream Evidence Pack integration.
Proof spine I1-I7.
Temporal memory receipts and the core proof summary are deterministic and byte-identical across proof gates.
Fail-closed tenant isolation rejects missing, empty, aliased, and foreign tenant paths before memory can leak.
Replay, leasing, restart, retry, and outbox durability prove no lost writes across deterministic reconstruction paths.
Canonical truth lives in the authoritative store while the vector index remains disposable and replayable.
Identical canonical payloads resolve to the same shard identity and idempotent retries do not create duplicate records.
Trust decay and reinforcement remain deterministic, with floors and ceilings preventing poisoned memory from winning by mass alone.
Governed mode signs receipts with Ed25519 and verifies tamper-detectable Evidence Packs without making signing mandatory for open-core receipts.
Memory that can be replayed and verified.
Cortex is Evidentiary Memory, also called Verifiable Memory. Every canonical fact is recorded so it can be independently checked, not merely asserted.
Canonical truth lives in append-only spine records that preserve exactly what happened and cannot be reordered or rewritten.
Gravitational Recall orders what surfaces during retrieval. Gravity weights are recall ordering only and never gate canonical truth.
Epoch Roots anchor the state of memory at each epoch so any later claim can be checked against a fixed, verifiable root.
Replay and counterfactual recall reconstruct prior memory states for inspection. Both are read-only and cannot mutate canonical history.
When a required anchor is missing, recall fails closed rather than returning unverifiable memory as if it were truth.
Deterministic outputs you can audit.
One portable auditor-grade bundle composing I1-I7 with content-addressed Merkle identity and all_checks_passed aggregate status.
Core proof summary, invariant manifest I1-I7, deterministic JSON output, and byte-identical proof gates.
Deterministic benchmark reports with provider metadata, stable ordering, CI upload support, and regression-grade comparison outputs.
Ed25519 receipt signing, deterministic manifest/hash tree generation, tamper detection, and historical-key verification coverage.
Unsigned open-core receipts remain allowed where governed signing is not enforced.
Governed signing, key lifecycle support, and Evidence Pack integrity provide tamper-evident verification for verifier-heavy deployments.
CI uploads proof and benchmark artifacts, invariant-manifest checks cover I1-I7, proof_bundle_id equals the deterministic Merkle root, and byte-identical double-run gates keep proof outputs reproducible across reruns.
Remembering useful context is not enough.
Most agent memory systems optimize for remembering useful context. Cortex optimizes for proving memory correctness under failure, tenancy, replay, indexing drift, trust decay, and governed audit.
Cortex provides durability and replay proof. Transactional outbox, leasing, replay proofs, idempotence, and byte-identical artifacts make every execution reconstructable and verifiable.
Most memory systems optimize recall. Cortex optimizes correctness.
Most memory systems optimize recall. Cortex optimizes correctness.
Most memory systems retrieve context. Cortex proves memory lineage.
Most memory systems trust their indexes. Cortex treats indexes as disposable derivatives.
Most memory systems log after the fact. Cortex emits deterministic proof artifacts you can verify.
Memory you can verify, not just trust.
Governed mode signs receipts with Ed25519.
Verifier accepts valid signatures.
Verifier rejects tampered receipt payloads.
Verifier rejects signatures from revoked keys.
Verifier accepts signatures from retired historical keys.
Manifest/hash tree is deterministic and tamper-detectable.
Governed signing composes into the unified proof bundle as I7.
Cortex provides cryptographic auditability. Ed25519 signing, tamper rejection, revoked key rejection, retired key acceptance, deterministic Evidence Pack manifest and hash tree, and proof bundle composition let any verifier confirm memory integrity independently.
What this surface owns.
Use Cortex when you need memory that preserves canonical truth and can be verified later.
How do you verify that the memory layer is correct?
- unified proof bundle
- I1-I7 proof spine
- content-addressed proof identity
- Evidence Pack verification
- vector database positioning
- chat history cache framing
- runtime execution governance
- canonical truth stored in the index