One command. Seven proof families. Content-addressed evidence.
Keon Cortex is a deterministic AI memory substrate with a unified proof bundle, authoritative truth separation, benchmark artifacts, and governed Evidence Pack verification.
Define the memory substrate responsible for canonical truth, receipt-backed reconstruction, and proof-oriented verification.
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
Proof-oriented capabilities.
- Separates canonical memory truth from disposable retrieval surfaces. The vector index is derivative. The document store is authoritative.
- Publishes cortex proof-bundle as a verify-all artifact that composes I1-I7 into one portable proof bundle.
- Makes the proof bundle content-addressed through a deterministic Merkle root where proof_bundle_id equals merkle_root.
- Emits stronger temporal memory receipts and retrieval influence receipts so buyers can inspect what memory existed and why it influenced retrieval.
- Generates deterministic proof and benchmark artifacts, with governed mode adding signed receipts and tamper-detectable Evidence Pack verification.
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.
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.
One command. Seven proof families. Deterministic output. Content-addressed evidence.
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 the courtroom binder: 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.
Receipts and memory semantics got stronger.
Stronger temporal memory receipts make the evolution of memory state reconstructable, not merely asserted.
Retrieval influence receipts show selected, excluded, ranked, and degraded memory paths instead of hiding retrieval behavior.
Fact slots, duplicates, and reinforcement remain distinguishable so strengthening a claim does not collapse lineage semantics.
Outbox leasing, safe reprocessing, restart tolerance, and idempotent replay behavior are proof-backed rather than implied.
Decay and reinforcement are hardened so low-trust memory cannot become authoritative by repetition alone.
Proof and benchmark outputs are generated as stable artifacts suitable for CI upload, comparison, and independent review.
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 become the commercial differentiator for verifier-heavy deployments.
CI now 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.
Mem0, LangGraph/LangMem, Letta, LlamaIndex, Zep/Graphiti, Cognee, and Hindsight mostly optimize for agents remembering useful context. Cortex optimizes for proving memory correctness under failure, tenancy, replay, indexing drift, trust decay, and governed audit.
Verdict: Cortex leads on durability/replay proof. Transactional outbox, leasing, replay proofs, idempotence, and byte-identical artifacts are not the normal pitch in this market.
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.
The commercial moat is audit infrastructure.
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.
Verdict: Cortex leads on cryptographic auditability. Ed25519 signing, tamper rejection, revoked key rejection, retired key acceptance, deterministic Evidence Pack manifest/hash tree, and proof bundle composition are not memory features. They are audit infrastructure.