MAQS-Way v0.2 Released: Setting Verifiable Standards for AI Long-Term Memory

Most release notes talk about what's been done. This one starts with what hasn't.

MAQS-Way v0.2 is officially released. It's no longer a preview version, but the first minor release of a practical standard for AI long-term memory. Unlike typical software releases, this version proactively discloses 12 known gaps, each with an assigned owner and target version, listed directly in the specification document. Author Aleksandr Kossarev calls this approach "by design."

The Missing Middle Layer

What MAQS-Way seeks to fill is a gap that has been battered by policy documents and enterprise internal audit folders, yet never systematically described.

The policy layer specifies "what must hold true," such as GDPR Article 17, EU AI Act Articles 12/13/19, RBAC, and so on. The audit layer has checklists like MAQS v1.6, backed by the sediment of actual production incidents. But between policy and audit, there has always been a missing path layer: which specific implementation should be chosen, and how to prove it actually works.

MAQS-Way is that path layer. It contains 8 principles (P1–P8), an OMPS-based data model, lifecycle management, and measurable verification methods (LoCoMo, LongMemEval, deletion lattice, negative testing). According to the author, today it is "a description with partially executable checks," with the rest declared and assigned owners, rather than pretending to have been verified in production environments.

OMPS (Open Memory Persistence Schema) is a schema specification used by MAQS-Way to describe the underlying data contract of AI memory systems. It defines core entities such as memory entries, sources, tenant boundaries, and lifecycle states, along with their relationships—similar to a database schema, but oriented toward cross-system memory persistence semantics. OMPS's goal is to enable different implementations (such as Mem0, Graphiti, Letta) to be audited and compared under the same field semantics, turning "whether a memory system is compliant" from a subjective judgment into a mechanically checkable structural problem. The way-v0.1.3 frozen by MAQS-Way v0.2 is precisely a concrete version snapshot of OMPS, independent of the standard release number, to ensure the stability of the data contract.

Verification Over Trust: The Audit Actually Runs

What makes MAQS-Way most distinctive is that all claims are executable. The entire verification process requires just one command:

$ python3 schemas/maqs_way_audit.py all
schema 4/4 + manifest 12/12 + declared 8/8 (005 ∈ declared) + executed (canon-pin) 1/1 + namespaces ok
GAP (enumerated, not folded): B4 -> owner SPEC §2.5, closes in v0.3
GATE GREEN

The output means: 4 schemas passed, 12 manifest entries passed, 8 behaviors declared (and honestly labeled as "declared" rather than "verified"), 1 number pinned to specification, namespace validation passed—and that known gap is printed out rather than hidden.

The key detail is how the gate handles gaps: it lists gaps loudly while keeping the green light. A version can carry gaps, but must never carry silent gaps. The "green light" here certifies compliance with release rules—including the rule that "every gap is listed"—not the absence of problems. This design builds trust in the standard on transparency rather than perfection.

LoCoMo (Long-Context Memory Benchmark) and LongMemEval are benchmark test suites for evaluating long-term memory capabilities. LoCoMo focuses on factual recall and consistency across multi-turn long conversations, while LongMemEval covers broader long-term memory tasks, including temporal reasoning, conflict resolution, and forgetting verification. In MAQS-Way, they are used as measurable verification methods rather than mere feature demonstrations—audit reports cite specific test results to prove whether a given principle (such as contradiction invalidation or aging decay) actually takes effect. Graphiti was rated as having "the most complete evaluation story" precisely because its unit tests, end-to-end tests, and LongMemEval oracle are all present, forming a closed-loop evidence chain.

Three Independent Codebases, One Yardstick

The MAQS-Way team applied the checklist to three open-source memory systems, using static reading, file:line evidence, and a helpful rather than critical tone. Three codebases, one checklist, each system rated for "exemplary" items and gap items, with the same yardstick for plus and minus points.

An example of how an observation becomes a verdict: in Mem0, the tenant filter reaches the vector store before top-k (main.py:1471), so isolation is proven by "attempting a violation" rather than judging by whether a filter exists. This corresponds to MAQS principle G1 and is executable.

The results from three complete reports are as follows:

• Mem0: Tenant isolation is exemplary (pre-top-k filter); partial compliance on source traceability, aging (decay limited to platform layer), deletion residue, and write atomicity; gaps in trust types and built-in evaluation tools.
• Graphiti: Contradiction-as-invalidation mechanism is exemplary (old edges retained and marked expired_at); the most complete evaluation story among the three (unit tests + end-to-end tests + LongMemEval oracle); gaps in audit receivers and unscoped search.
• Letta MemFS client: Fail-closed isolation by construction; sufficient policy testing depth; gap in aging mechanisms (budget only, no TTL).

This cross-codebase horizontal audit method itself deserves attention: it turns "standard" from paper text into actionable comparison, while maintaining a constructive rather than adversarial stance toward open-source projects.

Mem0, Graphiti, and Letta MemFS are three open-source implementations focused on AI memory, with different design orientations. Mem0 is centered on vector storage, emphasizing tenant isolation and scalable writes; Graphiti is based on a temporal knowledge graph, using edge expiration (expired_at) to achieve contradiction resolution; Letta MemFS manages memory as a file system, focusing on fail-closed-by-construction policies. MAQS-Way uses the same checklist to statically audit all three, providing evidence in file:line form, making cross-system horizontal comparison possible—this is both standard implementation verification and a constructive peer-review mechanism in the open-source ecosystem.

Open Gaps and Closing Timeline

All remaining gaps have been rescheduled to v0.3 through explicit release decisions, with none quietly handled.

Specifically: B4 write atomicity; normalization of E10/E11, I10–I12, I14, I15, P9/P10; dead code rule 0.5a and drift threshold 0.6a—twelve in total, each with an owner.

A detail about the data model's status: it has been frozen (schema_version way-v0.1.3, while the release version is v0.2). All v0.2 changes are at the presentation and test framework level, without touching the data model. This separation of version numbers from specification version numbers allows the standard's presentation layer to continue evolving while the underlying data contract remains stable.

How to Participate

MAQS-Way's repository, release page, and discussion area are all open. The author particularly emphasizes one feedback mechanism: if you find misreadings in the audit report, you can file an issue, and the correction will land as a second commit—discovered content will never be silently rewritten.

Author Aleksandr Kossarev is from Jõgeva, Estonia, and he summarized the project's entire stance in one sentence: Don't check whether a mechanism exists; check whether it actually works.

For a project trying to become an "AI long-term memory standard," this approach of writing gaps into the specification, making verification into executable commands, and recording corrections in commits may be more convincing than any feature list. After all, in the field of AI memory, the biggest risk has never been the lack of mechanisms, but mechanisms that appear to exist yet cannot withstand verification.

One-line Summary

MAQS-Way v0.2 releases a verifiable standard for AI long-term memory, proactively disclosing 12 gaps with executable audits.

Paragraph Summary

MAQS-Way v0.2 is officially released as the first minor version standard for AI long-term memory, filling the gap in the path layer between policy and audit. Its most distinctive feature is the proactive disclosure of 12 known gaps, each assigned an owner and target version, all auditable via a single command. The gate mechanism allows versions to carry gaps but never silent gaps; the green light certifies compliance with release rules rather than flawlessness. The team also audited three open-source memory systems—Mem0, Graphiti, and Letta MemFS—using the same checklist, each rated for exemplary items and gaps. The data model has been frozen as way-v0.1.3; all v0.2 changes concern only presentation and test frameworks, with the core stance: "Don't check whether a mechanism exists; check whether it actually works."