Memory + Dreaming + Audit, On Your Machine

For a year we shipped OMEGA as a local memory engine for AI agents. Hybrid retrieval, contradiction detection, multi-agent coordination, 95.4% on LongMemEval. Useful, but narrow. A memory system can hand the agent the right context and still leave the user trusting a vendor for everything else: scheduled hygiene, audit trails, multi-instance exchange, structured-data guarantees. Cloud-only systems own that whole stack.

The Sovereign Frontier Memory Stack arc closed all of it on your machine. Twelve modules, up to 134 MCP tools, every one of them auditable, federable, and tunable. This post walks each piece and the moat it opens.

Registering 134 MCP tool schemas at handshake spends roughly 13,000 tokens of the agent's system prompt before the first user message arrives. Most sessions touch 25 to 30 of those tools. The other 100 sit in context as bloat, paid on every turn whether they fire or not.

The new OMEGA_MODE environment variable gates which modules load at server start. Default is solo, which ships core memory plus dreaming, audit, and typed memory. Roughly 28 tools. About 4K tokens.

Additive syntax handles the in-between cases: OMEGA_MODE=solo,federation loads federation on top of the solo baseline without pulling in coordination. Per-tool overrides via OMEGA_TOOLS_INCLUDE and OMEGA_TOOLS_EXCLUDE handle the rest. The new omega_mode tool, always loaded, reports the active profile and the exact env var to expand. We mirrored the GitHub MCP server's CLI idiom so engineers already know the shape.

Why restart-to-switch and not live reload? Claude Code does not honor the MCP tools/list_changed notification ( anthropics/claude-code#13646). Runtime gating would silently no-op. Restart-to-switch is the honest UX.

A long-lived memory store accumulates stale ideas, duplicate phrasings, and decisions superseded by later ones. Without periodic consolidation it gets noisy, slow, and a poor signal source for the agent. Dreaming is the answer: scheduled analyzers walk a store, propose mutations, and either queue them for your review or auto-apply against per-store policy.

Four MCP tools: omega_dream runs an analyzer and creates a pending drm_ job with proposed mutations. omega_dream_diff shows what it wants to change. omega_dream_apply executes the ops through the regular mutation path so every change appends to the immutable version chain. omega_dream_discard rejects the proposal.

The substrate schedules itself. No cron, no orchestrator, no outbound call. Each store carries its own policy: cadence, analyzers, auto-apply threshold. Every applied dream lands as actor_kind=dream in the version chain so a regulator can later distinguish scheduled hygiene from manual edits.

Cloud-only memory cannot make this offer. Anthropic's managed agents memory consolidates on their schedule, in their compute, with their billing meter. OMEGA's dreaming runs on your machine, on a schedule you set, with cryptographic proof of every consolidation.

Cloud-only memory providers cannot make a court-admissible promise about your history. Their terms preclude it. Data can be revoked, modified, or lost. OMEGA produces a cryptographically signed artifact over the immutable memver_ chain that anyone with the public key can verify, forever, offline, with a roughly 200-line verifier.

An Ed25519 keypair lives at $OMEGA_HOME/audit/, generated on first use, never leaves your machine. An export builds a Merkle tree over a slice of the version chain and signs the root. Verification is a three-layer offline check: recompute every leaf hash, rebuild the Merkle root from the recomputed leaves, verify the Ed25519 signature against the rebuilt root.

Per-leaf inclusion proofs let you hand over one decision (for legal discovery, for example) without revealing siblings. Selective disclosure for compliance handovers. The whole surface is four MCP tools.

Customers leave OMEGA tomorrow and the signed artifacts still verify. The math is yours, not ours. That is the difference between "we promise to be careful with your data" and "math plus your key prove what happened."

Anthropic's managed agents memory is single-tenant cloud. No protocol exists for two customers to exchange signed memory subsets with verifiable origin. Federations of sovereign nodes are structurally precluded on a cloud-only substrate. OMEGA Pro ships the primitive.

Six MCP tools. Export builds a signed manifest containing a memory subset. Trust-add registers a peer's Ed25519 public key in the local allowlist (and trust-list / trust-remove manage it). Verify runs a three-layer integrity check (per-memory leaf hash, Merkle root, signature). Import merges verified memories into the local store, recording a federation_origin lineage block on every imported row so you can always trace where it came from.

Merge-time dedup on (content_hash, entity_id) keeps imports idempotent. Re-importing the same manifest is a no-op. The default trust mode is trusted_keys_only, so imports from peers not in the allowlist are refused without ceremony.

Federation reuses the same Ed25519 keypair as the audit chain, so one local identity covers both export paths. Multi-instance organizations, defense partners, air-gapped peers, cross-org legal discovery: all become possible when the exchange substrate is sovereign by design.

Free-text memory is the right primitive for most agent work. Notes, decisions, lessons, observations. But when you build a predictive system, forecasting platform, or decision-tracking workflow, you need structure. A typo in a forecast field shouldn't be discovered when the regression model fails six weeks later. It should fail at the store boundary, immediately.

Four Pydantic v2 schemas ship today: Calibration (a subjective probability with rationale and observation window), Forecast (a point prediction with confidence interval and resolution criterion), Anchor (a measured baseline used to ground forecasts and detect drift), and Outcome (a resolved observation tied to a prior forecast). Each model uses extra="forbid" so a typo'd field raises immediately, not downstream.

Three MCP tools wire it up. omega_typed_store validates and inserts. omega_typed_query filters on a typed_schema discriminator via SQLite's json_extract (more reliable than LIKE substring matching) and revalidates each row through the Pydantic class. omega_typed_schemas returns the full JSON-schema for each registered model so callers can discover field constraints before storing.

The first consumer is Meridian, the predictive product line we are building inside Sosa Research. Calibration rationale, anchor evolution, and forecast-versus-actual mining all ride on these primitives without each needing its own schema layer. Future predictive products compound the moat instead of duplicating it.

Anthropic Memory plus dreaming, on your machine, with a court-admissible audit trail. That sentence is technically true now. The pieces stack:

• Bi-temporal point-in-time replay (P0.3): omega_query(valid_at=...) reconstructs what you believed on any date. Cloud Memory exposes "current" only.
• Content-hash CAS (P1.5): precondition_sha256 makes concurrent multi-agent writes safe with explicit 409 plus current-hash echo.
• Redact with preserved attribution (P1.7): right-to-erasure compliance without breaking the audit chain or forgetting who did what.
• Signed audit chain (P3.15): court-admissible memory lineage, three-layer offline verifier, per-leaf inclusion proofs.
• Federation manifests (P3.16): signed cross-instance exchange, trust allowlist, idempotent merge with origin lineage.
• Autonomous dreaming (P2.10): scheduled, per-store consolidation that records every applied change in the signed chain.
• Typed memory (P3.17): Pydantic v2 schemas for predictive workloads, with extra="forbid" at the boundary.
• Tunable surface: solo, team, or enterprise profile gates what loads. About 13K tokens back for the dominant solo case.

The deeper unlock is vendor-trust elimination. Customers do not have to trust OMEGA, Anthropic, or any cloud. They trust math plus their own key. That is structurally different from "we promise to be careful with your data," and it is a positioning cloud-only competitors cannot match.

Three buyer segments became reachable that were not before. Defense, healthcare, and certain financial verticals cannot use cloud Memory at all. OMEGA Pro is the only viable substrate, and federation lets them collaborate cross-org without surrendering data to a hub.

Compliance teams in regulated industries get court-admissible memory lineage without rebuilding a custom audit stack. The same Ed25519 keypair signs both audit exports and federation manifests, so one local identity covers both.

Downstream products inside our own house ride the same substrate. Meridian, our forecasting platform, gets typed memory primitives without inventing them. Each future predictive product compounds the moat instead of duplicating it.

All of this is in omega-platform v1.5.1. Existing Pro installs get it on the next restart. omega_welcome shows the active mode profile on its first line. omega_mode spells out what loaded, what was skipped, and how to expand.

Fresh installs:

The LLM is rented. The intelligence is owned. Now the hygiene, the audit, the exchange, and the schema are owned too.

Get OMEGA Pro · Documentation · How OMEGA compares