Conformance Levels

Overview

Implementations declare conformance at one of four levels. Each level is a strict superset of the previous — a Level 2 implementation satisfies all Level 0 and Level 1 requirements as well.

Level 0 — Starter

The minimal viable implementation. A developer can adopt this in an afternoon.

An implementation conforms to Level 0 if it:

1. Implements REGISTER with id and role fields.
2. Implements RECORD in both draft and committed modes.
3. Validates that intent.purpose is present and non-empty on every RECORD.
4. Rejects RECORD with MISSING_INTENT if intent is absent.
5. Auto-generates id, epoch, source, and status on every memory unit.
6. Implements ATTUNE with Required Scope (role and max_units).
7. Returns memory units scored and sorted by relevance (algorithm is implementation-defined).
8. Excludes the requesting agent's own memory units from ATTUNE results by default.
9. Excludes retracted and superseded memory units from ATTUNE results.
10. Returns relevance_score and relevance_reason for each result.
11. Uses the standard message envelope on all messages.

Level 0 MAY omit:

• Persistence (in-memory only is acceptable)
• Logical clocks (epoch MAY be a simple counter or 0)
• Conflict detection
• Subscriptions
• The Coordination Extension
• Authentication

Level 1 — Core

Memory persists. Events are ordered. Contradictions get flagged — mechanically, not semantically.

An implementation conforms to Level 1 if it meets all Level 0 requirements AND:

1. Persists memory units to durable storage that survives process restarts.
2. Maintains an append-only event log of all operations.
3. Implements Lamport logical clocks: each operation increments the epoch; incoming messages update the local clock to max(local, received) + 1.
4. Carries confidence, when supplied, unchanged through every read path, and never uses it to rank relevance or resolve a conflict. Confidence remains OPTIONAL — it is never required.
5. Implements DEREGISTER.
6. Implements DETECT in list mode, detecting both explicit contradicts relations and mechanical (key-value) conflicts.
7. Creates a Conflict object when a RECORD includes a contradicts relation, or when mechanical detection finds a match. At Level 1 this Conflict is the lightweight, stateless form.
8. Implements ATTUNE with since_epoch parameter for polling-based subscriptions.
9. Returns unresolved conflicts in the ATTUNE response.
10. Implements REGISTER with capability exchange (Field returns field_capabilities).
11. Implements REPLAY, reconstructing the event timeline from the append-only log at "full_trace" depth, and following a unit's supersession chain when requested.
12. Handles supersedes and retracts relations on RECORD: setting the target's status accordingly, and enforcing that only a unit's original author may retract it.

Level 2 — Standard

Relevance gets smart. Conflicts get resolved. Agents get notified.

An implementation conforms to Level 2 if it meets all Level 1 requirements AND:

1. Computes vector embeddings for memory unit content.
2. Implements semantic relevance scoring in ATTUNE using embeddings.
3. Supports Extended Scope fields: max_tokens, interests, active_task_id, relevance_threshold.
4. Implements token budget management in ATTUNE (truncation and/or summarization).
5. Implements DETECT in all three modes (check, scan, list) with at least one automatic detection method beyond explicit relations and Level 1's mechanical detection (semantic, logical, or temporal).
6. Implements MERGE with at least three strategies: last_write_wins, confidence_weighted, human_escalation. Conflicts become the stateful, ID-addressable form, with the full detected → resolving → resolved lifecycle.
7. Implements SUBSCRIBE with push notifications (WebSocket, SSE, or equivalent).
8. Implements HANDOFF with structured context packaging (Coordination Extension).
9. Implements REPLAY at "summary" and "detailed" depth, including human-readable summary text and agents_involved aggregation on top of the raw timeline Level 1 already provides.
10. Implements COMPACT with at least the archive strategy.

Level 3 — Full

Production-grade orchestration with coordination, security, and full audit trails.

An implementation conforms to Level 3 if it meets all Level 2 requirements AND:

1. Implements the full Coordination Extension: COORDINATE and SESSION.
2. Implements the full task state machine with all transitions.
3. Implements MERGE with all seven conflict resolution strategies.
4. Supports agent authentication (at minimum: token-based).
5. Enforces the authority hierarchy for privileged operations.
6. Implements memory unit visibility rules (session scoping and role-based filtering).
7. Implements COMPACT with all three strategies (archive, summarize, purge).
8. Implements at least two transport bindings.

Declaring Conformance

Implementations MUST declare their conformance level in:

1. The REGISTER response in field_capabilities.conformance_level.
2. Their documentation.

Implementations MUST NOT claim a conformance level they do not fully satisfy. Partial implementations SHOULD declare the level below the first unmet requirement.