AI application
App-defined
StructureValidationChangeAuditGovernance
A protocol for persistent AI memory.
MOPS is a vendor-neutral protocol for persistent AI memory. It defines shared, deterministic rules for how memory is identified, structured, changed, verified and governed across agents, models, devices and storage systems.
MOPS 1.0-rc4Public Review
02The problem
Persistent AI memory has no common protocol.
Every system has to build its own.
Applications, agent frameworks, device environments and vendor ecosystems therefore define their own memory structures and rules.
Each implementation can decide for itself how memory is represented, validated, changed, versioned, audited, retained and governed.
Those decisions do not have to agree.
Memory can work inside one system and still become difficult to preserve, verify or move when models change, agents collaborate, devices change, storage changes or users move between vendors.
Diagram — Divergence
No common persistent-memory protocolindependent implementations
Agent framework
Framework-defined
StructureValidationChangeAuditGovernance
Device environment
Device-defined
StructureValidationChangeAuditGovernance
Vendor ecosystem
Provider-defined
StructureValidationChangeAuditGovernance
Independent definitionsDifferent memory semantics
Without shared rules, the same underlying information can acquire different structures, transition behaviour, histories and governance.
The result is fragmented memory semantics and a growing layer of custom integration between otherwise capable systems.
03The common protocol
A common protocol for persistent AI memory.
MOPS standardises the persistent-memory rules that systems currently have to define independently.
It defines how persistent memory is identified, structured, validated, changed, committed, verified, audited and governed.
Applications, agents, models, devices and storage systems can continue to evolve independently. MOPS defines the memory semantics that need to remain stable across those changes.
This creates a shared foundation for long-lived AI memory without prescribing the model, application architecture or physical storage implementation.
Diagram — Shared protocol layer
Modelsvia Agents
ApplicationsAgentsDevice runtimes
Shared M-OP Requests
MOPS
Common persistent-memory protocol
Shared deterministic rules
identityschemastateoperationstransitionslineagepolicyconformance
Backing-store adapter boundary
Local storeDatabaseDistributed storage
A stable foundation for long-lived AI memory.
Systems and infrastructure can evolve independently while persistent-memory semantics remain explicit and verifiable.
04What a common memory protocol enables
A shared foundation for AI memory to grow on.
Standardise the persistent-memory foundation so everything around it can continue to evolve.
MOPS gives persistent memory common semantics without prescribing the models, applications, agents, devices or storage systems that build on them.
Memory that survives change
Models can be upgraded, applications rebuilt, devices replaced and storage changed without requiring persistent memory to lose its identity, meaning or history.
Namespace · Schema Version · State · Lineage
Systems that understand the same memory
Explicit structures and deterministic rules give independent implementations a shared way to interpret, validate and operate on persistent memory.
Schema · State · M-OP · Conformance
Safe evolution
Memory structures can evolve through explicit versions and migrations while preserving what earlier State meant and how it was produced.
Schema Version · Migration · State · Audit Trail
Multiple agents working from the same foundation
Agents can act on shared persistent memory using common identity, operation and transition semantics instead of maintaining incompatible private interpretations.
Namespace · M-OP · State · Commit Record
Memory that can be inspected and governed
Accepted changes preserve verifiable lineage, while common policy semantics define access, retention, expiry, deletion and redaction behaviour.
Commit Record · Audit Trail · Policy
Innovate with confidence
Applications, models, agents, devices and storage technologies can develop independently with confidence because the persistent-memory semantics they rely on remain explicit and testable.
Conformance · Extensions · Custom Schemas
By replacing fragmented memory semantics with a shared foundation, MOPS allows the AI ecosystem to evolve independently without continually reinterpreting or reinventing persistent memory.
05Continuity through change
Memory will change.
Trust must survive.
Persistent memory may be retained for years while people, circumstances and knowledge continue to change. New information is added, earlier conclusions are corrected and some information may need to be removed.
As more models, agents and systems interact with that memory, each change creates a need to preserve continuity. If changes are interpreted or applied differently, a system may retain what memory says now while losing a reliable account of how it arrived there.
MOPS provides shared rules for how persistent memory changes. By making those changes explicit, consistent and verifiable, MOPS can enable memory to evolve across agents, systems and time without silently severing its continuity.
MOPS does not determine whether a remembered claim is true or guarantee that every accepted change is correct. It provides a common basis for establishing what changed, what was accepted and what remains authoritative.
Memory can evolve while preserving a verifiable account of what changed and what remains authoritative.
06Determinism
AI can vary.
Memory must behave consistently.
Models may interpret the same information differently, and Agents may propose different actions. MOPS does not make that reasoning deterministic or standardise which action an Agent chooses to propose. Its deterministic boundary begins when that choice is expressed as a governed memory operation.
That boundary is one application of a broader principle. Persistent memory may be processed by different Agents, models, devices, vendors, runtimes and storage systems over many years. Without deterministic protocol behaviour, differences between those implementations can recreate fragmentation inside the shared layer itself.
The risk
If identical governed inputs can be processed differently, one implementation may accept an operation another rejects, produce a different State, return a different result or order the same history differently. Memory can then diverge because of implementation detail—not because the inputs or declared rules changed.
Core principle
Determinism removes that source of variation from the behaviour MOPS governs. Given the same governed inputs, configuration and prior State, conformant implementations must produce equivalent observable outcomes—whether an operation succeeds or fails.
This principle applies throughout MOPS: to validation, State transitions, ordering, queries, rendering, policy evaluation and errors.
What it supports
Determinism is not the whole solution. It provides the repeatable foundation that conformance testing, reproducible audits, reliable synchronisation and migration, and independent verification depend on.
Combined with MOPS’s shared semantics, schemas, governance and verifiable history, it allows implementations to differ without silently changing the governed result.
Different implementations. Same governed inputs. Equivalent protocol outcomes.