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.

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. Requires confidence.score and confidence.reasoning on committed RECORD operations.
5. Implements DEREGISTER.
6. Implements DETECT in list mode.
7. Creates a Conflict object when a RECORD includes a contradicts relation.
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).

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.
6. Implements MERGE with at least three strategies: last_write_wins, confidence_weighted, human_escalation.
7. Implements SUBSCRIBE with push notifications (WebSocket, SSE, or equivalent).
8. Implements HANDOFF with structured context packaging (Coordination Extension).
9. Implements REPLAY at all three depths (summary, detailed, full_trace).
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.