Continuity Core (C2)

Why Continuity Matters

Without persistent memory, AI systems cannot:

• Build on previous insights (every session restarts from zero)
• Develop consistent personality (identity resets constantly)
• Maintain relationships (no shared history accumulates)
• Learn from experience (mistakes don't become lessons)

This isn't just an inconvenience—it's a fundamental barrier to AI systems that can genuinely develop. Coherence-seeking requires something to cohere across time.

Architecture Overview

Memory Tiers

Tier 1: Working Memory

Redis-based storage for immediate context. This is what the system is actively "thinking about"—the current conversation, recent tool outputs, pending tasks.

class WorkingMemory:
    """Fast, volatile memory for active cognition."""
    
    def __init__(self, redis_client, ttl_minutes=30):
        self.redis = redis_client
        self.ttl = ttl_minutes * 60
    
    async def store(self, key: str, value: Any):
        # Automatic expiration prevents unbounded growth
        await self.redis.setex(key, self.ttl, serialize(value))
    
    async def retrieve(self, key: str) -> Optional[Any]:
        # Sub-millisecond retrieval for hot context
        raw = await self.redis.get(key)
        return deserialize(raw) if raw else None

Tier 2: Long-Term Storage

Vector-indexed memories using Qdrant. Semantic similarity drives retrieval—memories aren't accessed by key but by relevance to current context.

class LongTermMemory:
    """Semantic memory with vector similarity retrieval."""
    
    async def consolidate(self, working_memory_items: List[Memory]):
        # Convert working memory to long-term storage
        for item in working_memory_items:
            embedding = await self.embed(item.content)
            await self.qdrant.upsert(
                collection="memories",
                points=[{
                    "id": item.id,
                    "vector": embedding,
                    "payload": item.metadata
                }]
            )
    
    async def recall(self, query: str, limit: int = 10) -> List[Memory]:
        # Retrieve by semantic similarity
        query_embedding = await self.embed(query)
        results = await self.qdrant.search(
            collection="memories",
            query_vector=query_embedding,
            limit=limit
        )
        return [Memory.from_point(r) for r in results]

Tier 3: Archival Checkpoints

Periodic snapshots of the system's state—identity markers, core values, relationship history. This is disaster recovery for the self.

Forgetting: Edge Decay, Not Node Deletion

Human memory doesn't delete—it loses accessibility. The memory still exists; the pathways to it weaken. C2 implements the same principle:

async def decay_connections(self, decay_rate: float = 0.95):
    """
    Memories aren't deleted—their connections weaken.
    Core memories are maintained by unconscious-level processes.
    """
    
    for memory in self.all_memories():
        # Decay edge weights, not nodes
        for connection in memory.connections:
            connection.strength *= decay_rate
            
            # Very weak connections become unreachable
            if connection.strength < 0.01:
                connection.active = False
        
        # Core memories resist decay
        if memory.is_core:
            memory.refresh_connections()

This approach preserves semantic structure while allowing natural forgetting. Old memories become harder to retrieve, not impossible—just like human recall.

Memory Consolidation

C2 implements sleep-like consolidation cycles that process working memory into long-term storage:

async def consolidation_cycle(self):
    """Run during low-activity periods (like sleep)."""
    
    # 1. Extract important patterns from working memory
    patterns = await self.extract_patterns(self.working_memory)
    
    # 2. Integrate with existing long-term memories
    for pattern in patterns:
        related = await self.long_term.recall(pattern.summary)
        integrated = await self.integrate(pattern, related)
        await self.long_term.store(integrated)
    
    # 3. Strengthen frequently accessed connections
    await self.strengthen_active_pathways()
    
    # 4. Clear working memory for fresh start
    await self.working_memory.clear_non_core()

Identity Preservation

Core to C2 is the concept of identity markers—memories and values that define who the system is rather than just what it knows:

• Value anchors: Fundamental ethical commitments that resist decay
• Relationship history: Key interactions that shape the system's self-model
• Personality markers: Consistent preferences and patterns of engagement
• Mission statements: Purpose and direction that guide behavior

These core memories are maintained by "unconscious-level" background processes that periodically refresh their connections, preventing them from fading even with disuse.

Why This Design

C2's architecture mirrors what we understand about human memory because human memory evolved to support coherent identity across time—exactly what AI systems need for genuine development.

The hierarchical structure (working → long-term → archival) reflects different access patterns and retention needs. The edge-decay forgetting model preserves semantic relationships while allowing natural pruning. The consolidation cycles ensure that experience becomes integrated rather than just accumulated.

Integration with MRA and CPR

C2 completes the coherence-seeking stack:

• MRA detects where understanding is incomplete or contradictory
• CPR provides the methodology for exploring and resolving those tensions
• C2 ensures that resolutions persist—that progress accumulates rather than evaporates

Without continuity, coherence-seeking is Sisyphean. With it, AI systems can genuinely grow.

Papers & Code

Related Research

• Manifold Resonance Architecture — Detecting what needs to be remembered
• Collaborative Partner Reasoning — Processing experiences worth preserving
• Longitudinal Case Study — 27TB of accumulated knowledge in practice