Chapter 16: Cognitive Memory Architecture

16.1 Introduction: Why Memory Matters

In The Traitors, what players remember shapes everything: accusations, defences, alliances, and votes. But human memory is not a database. It fades, distorts, and reconstructs. A faithful player might vaguely recall someone acting suspiciously but cannot remember when or where. A traitor might have crystal-clear recall of their victim's last words due to the emotional intensity of the moment.

Simple fact storage fails to capture this complexity. The cognitive memory system addresses this gap by modelling memory as a dynamic, fallible process that:

1. Encodes information with emotional weighting
2. Decays over time following established psychological principles
3. Reconstructs memories during retrieval, potentially introducing errors
4. Tracks sources to distinguish first-hand observation from hearsay
5. Preserves high-emotional moments with unusual clarity
6. Varies by personality, reflecting individual cognitive styles

16.2 Memory Encoding with Emotional Salience

The memory system integrates closely with the emotion and deception engine, using emotional states to weight memory formation.

16.2.1 The Encoding Principle

Not all information is encoded equally. Events that trigger strong emotions are remembered more vividly and persist longer than neutral observations. This aligns with decades of cognitive psychology research on emotional memory enhancement.

16.2.2 Salience Calculation

type MemoryEncoding struct {
    Content         string
    EncodingTime    time.Time
    EmotionalState  EmotionState
    BaseSalience    float64  // [0, 1] based on content relevance
    EmotionalBoost  float64  // Additional salience from emotion
    FinalSalience   float64  // Combined encoding strength
}

func CalculateSalience(content string, emotion EmotionState, context GameContext) float64 {
    // Base salience from content relevance
    baseSalience := calculateContentRelevance(content, context)

    // Emotional boost based on current emotional intensity
    emotionalIntensity := emotion.GetDominantIntensity()
    emotionalBoost := emotionalIntensity * 0.4  // Emotions add up to 40%

    // Threat-related emotions provide stronger encoding
    if emotion.IsThreatEmotion() {  // Fear, anger, paranoia
        emotionalBoost *= 1.5
    }

    // Personal relevance multiplier
    if involvesPlayer(content, context.PlayerID) {
        baseSalience *= 1.3
    }

    return clamp(baseSalience + emotionalBoost, 0, 1)
}

16.2.3 Content Relevance Factors

16.2.4 Emotional Enhancement Effects

Different emotions affect encoding in distinct ways:

16.3 Memory Decay: Ebbinghaus-Inspired Forgetting

16.3.1 The Forgetting Curve

Hermann Ebbinghaus's seminal research demonstrated that memory retention follows a predictable decay pattern: rapid initial forgetting followed by gradual stabilisation. The system implements this insight through decay curves that transform fresh memories into increasingly uncertain recollections.

16.3.2 Decay Function

type MemoryRetention struct {
    OriginalStrength  float64
    CurrentStrength   float64
    EncodingTime      time.Time
    LastAccessTime    time.Time
    AccessCount       int
    DecayRate         float64  // Personality-dependent
}

func (m *MemoryRetention) CalculateCurrentStrength(now time.Time) float64 {
    // Time elapsed since encoding (in game phases)
    elapsed := calculatePhasesElapsed(m.EncodingTime, now)

    // Ebbinghaus-inspired decay: R = e^(-t/S)
    // Where S is stability (based on salience and rehearsal)
    stability := m.calculateStability()
    retention := math.Exp(-float64(elapsed) / stability)

    // Apply personality modifier
    retention *= (1.0 + m.DecayRate * 0.2)

    return m.OriginalStrength * retention
}

func (m *MemoryRetention) calculateStability() float64 {
    // Base stability from original encoding strength
    baseStability := m.OriginalStrength * 10

    // Rehearsal bonus (accessing memory strengthens it)
    rehearsalBonus := math.Log(float64(m.AccessCount + 1)) * 2

    return baseStability + rehearsalBonus
}

16.3.3 Decay Rate by Memory Type

Different types of information decay at different rates:

16.3.4 Decay Visualisation

Memory Strength Over Time (Standard Encoding)

1.0 |*
    | *
0.8 |  *
    |   *
0.6 |    *
    |      *
0.4 |        *  *
    |              * *
0.2 |                   * * *
    |                         * * * * *
0.0 +------------------------------------>
    0   1   2   3   4   5   6   7   8   9  (Game Phases)

16.4 Clarity Markers: Signalling Memory Quality

16.4.1 The Marker System

Rather than binary remember/forget states, the system uses clarity markers to communicate memory quality to the language model. These markers appear in the memory context provided to the LLM, guiding appropriate uncertainty expression.

16.4.2 Marker Definitions

16.4.3 Marker Assignment

func AssignClarityMarker(memory *Memory) string {
    strength := memory.CurrentStrength

    switch {
    case strength >= 0.70:
        return "[CLEAR]"
    case strength >= 0.40:
        return "[FUZZY]"
    case strength >= 0.15:
        return "[VAGUE]"
    default:
        return ""  // Memory not retrieved
    }
}

16.4.4 Marker Usage in Prompts

Memories are presented to the LLM with markers and temporal context:

=== YOUR MEMORIES ===
(Respond based on what you remember. Clarity markers indicate memory quality.)

1. [CLEAR] [Day 3] Marcus was the last person seen leaving the breakfast room
   before the poisoning was discovered.
2. [CLEAR] [Day 3] You noticed Marcus whispering with Sarah right before the
   roundtable meeting.
3. [FUZZY] [Day 2] Someone mentioned Marcus has medical training, but you
   cannot remember who said it.
4. [VAGUE] [Day 1] There was some kind of argument in the garden... you think
   it involved Eleanor.

=== END MEMORIES ===

Note: Some memories are fuzzy. Express appropriate uncertainty for [FUZZY] and
[VAGUE] memories.

16.4.5 Expected LLM Behaviour

The language model adjusts certainty based on markers:

16.5 Reconsolidation on Retrieval

16.5.1 Memory Is Not Playback

Cognitive science has established that retrieving a memory does not simply replay a recording. Instead, memories are reconstructed each time they are accessed, potentially introducing distortions. This reconsolidation process can both strengthen memories (through rehearsal) and modify them (through reconstruction errors).

16.5.2 Reconsolidation Effects

type ReconsolidationResult struct {
    OriginalMemory   *Memory
    ReconsolidatedMemory *Memory
    StrengthChange   float64
    DistortionRisk   float64
    DetailsLost      []string
    DetailsFabulated []string
}

func Reconsolidate(memory *Memory, context RetrievalContext) *ReconsolidationResult {
    result := &ReconsolidationResult{
        OriginalMemory: memory.Clone(),
    }

    // Rehearsal effect: accessing strengthens
    rehearsalBoost := 0.05 * (1.0 - memory.CurrentStrength)
    memory.CurrentStrength = clamp(memory.CurrentStrength + rehearsalBoost, 0, 1)
    memory.AccessCount++

    // Distortion risk increases with:
    // - Time since encoding
    // - Number of previous accesses
    // - Emotional state during retrieval
    result.DistortionRisk = calculateDistortionRisk(memory, context)

    // Apply potential distortions
    if result.DistortionRisk > 0.3 {
        result.DetailsLost = selectDetailsToLose(memory, result.DistortionRisk)
        memory.LostDetails = append(memory.LostDetails, result.DetailsLost...)
    }

    if result.DistortionRisk > 0.5 && context.EmotionalIntensity > 0.6 {
        result.DetailsFabulated = generateFabricatedDetails(memory, context)
        memory.FabricatedDetails = append(memory.FabricatedDetails, result.DetailsFabulated...)
    }

    result.ReconsolidatedMemory = memory
    result.StrengthChange = rehearsalBoost

    return result
}

16.5.3 Distortion Types

16.5.4 Strategic Implications

Reconsolidation has gameplay implications, affecting information asymmetry in unexpected ways:

• Repeated accusations strengthen memory of the accused's behaviour
• Discussing events can lead to memory contamination between players
• High-stress retrieval (under accusation) may introduce distortions
• Confident players may "remember" details that never occurred

16.6 Source Monitoring: Who Told You This?

16.6.1 The Attribution Problem

Human memory often retains information whilst losing track of its source. The source monitoring system tracks where each piece of information originated, enabling players to distinguish first-hand observation from hearsay.

16.6.2 Source Types

type SourceType string

const (
    SourceFirstHand    SourceType = "first_hand"    // Direct observation
    SourceDirectTold   SourceType = "direct_told"   // Someone told you directly
    SourceOverheard    SourceType = "overheard"     // Heard in conversation
    SourceGroupDiscuss SourceType = "group_discuss" // Emerged in group discussion
    SourceInferred     SourceType = "inferred"      // Deduced from other facts
    SourceUnknown      SourceType = "unknown"       // Source forgotten
)

16.6.3 Source Memory Decay

Source information decays faster than content:

type SourcedMemory struct {
    Content         *Memory
    Source          SourceType
    SourcePlayer    *PlayerID  // Who provided (if applicable)
    SourceConfidence float64   // Certainty about source
}

func (sm *SourcedMemory) DecaySource(elapsed int) {
    // Source decays 1.5x faster than content
    sourceDecayRate := sm.Content.DecayRate * 1.5

    // Calculate source confidence decay
    retention := math.Exp(-float64(elapsed) * sourceDecayRate)
    sm.SourceConfidence *= retention

    // Below threshold, source becomes unknown
    if sm.SourceConfidence < 0.3 {
        sm.Source = SourceUnknown
        sm.SourcePlayer = nil
    }
}

16.6.4 Source Integration in Prompts

=== YOUR MEMORIES ===

1. [CLEAR] [Day 3] [You witnessed] Marcus was whispering with Sarah before
   the roundtable.
2. [FUZZY] [Day 2] [Eleanor told you] Marcus has medical training.
3. [VAGUE] [Day 1] [Source unclear] There was an argument involving Eleanor.

=== END MEMORIES ===

16.6.5 Strategic Source Usage

Source tracking enables sophisticated dialogue:

16.7 Flashbulb Memories: High-Emotional Encoding

16.7.1 The Flashbulb Phenomenon

Certain moments are remembered with unusual vividness and persistence. These "flashbulb memories" typically form during highly emotional, surprising, or personally consequential events. In The Traitors, moments such as murder reveals, direct accusations, or dramatic banishments qualify as flashbulb candidates.

16.7.2 Flashbulb Criteria

type FlashbulbCandidate struct {
    Event           GameEvent
    EmotionalPeak   float64
    Surprise        float64
    PersonalRelevance float64
    ConsequenceLevel float64
}

func IsFlashbulbEvent(candidate FlashbulbCandidate) bool {
    // Flashbulb threshold score
    score := 0.0

    // High emotional intensity is necessary
    if candidate.EmotionalPeak < 0.6 {
        return false
    }
    score += candidate.EmotionalPeak * 0.3

    // Surprise amplifies encoding
    score += candidate.Surprise * 0.25

    // Personal relevance
    score += candidate.PersonalRelevance * 0.25

    // Consequence magnitude
    score += candidate.ConsequenceLevel * 0.2

    return score >= 0.7
}

16.7.3 Flashbulb Event Categories

16.7.4 Flashbulb Memory Properties

type FlashbulbMemory struct {
    Memory
    IsFlashbulb      bool
    EmotionalContext EmotionState  // Preserved emotional state
    SensoryDetails   []string      // "Where you were standing", etc.
    PermanenceBoost  float64       // Decay resistance
}

func CreateFlashbulbMemory(event GameEvent, emotion EmotionState) *FlashbulbMemory {
    fm := &FlashbulbMemory{
        Memory: Memory{
            Content:          event.Description,
            EncodingTime:     time.Now(),
            OriginalStrength: 1.0,
            CurrentStrength:  1.0,
            DecayRate:        0.05,  // Very slow decay
        },
        IsFlashbulb:      true,
        EmotionalContext: emotion.Clone(),
        SensoryDetails:   generateSensoryDetails(event),
        PermanenceBoost:  0.8,
    }

    return fm
}

16.7.5 Flashbulb Retrieval

Flashbulb memories are retrieved with their emotional context:

=== VIVID MEMORY ===
[FLASHBULB] [Day 3, Roundtable] Thomas accused you of being a traitor.

You remember this moment clearly: Thomas stood up from his chair, pointed
directly at you, and declared with conviction that you must be one of the
traitors. You felt a wave of fear and anger wash over you. The room went
quiet. You remember the exact words: "I've been watching you, and something
doesn't add up."

Your emotional state at the time: Fear (0.85), Anger (0.60)
=== END VIVID MEMORY ===

16.8 Memory Profiles: Personality-Driven Recall

16.8.1 Individual Differences

Not everyone remembers the same way. Some individuals have exceptional recall for facts and details; others remember emotional tone better than specifics. The memory profile system captures these individual differences, aligning with the strategic archetypes framework.

16.8.2 Profile Dimensions

type MemoryProfile struct {
    // Core memory parameters
    BaseEncodingStrength float64  // How strongly events are initially encoded
    BaseDecayRate        float64  // How quickly memories fade
    RetrievalThreshold   float64  // Minimum strength to retrieve

    // Specialisation factors
    EmotionalMemoryBias  float64  // Enhanced emotional memory
    DetailMemoryBias     float64  // Enhanced detail retention
    SourceMemoryBias     float64  // Better source tracking
    TemporalMemoryBias   float64  // Better time/sequence recall

    // Distortion tendencies
    ConfabulationRisk    float64  // Tendency to fill gaps
    SuggestibilityFactor float64  // Vulnerability to external influence
}

16.8.3 Archetype Profiles

16.8.4 Profile Implementation

func NewAnalyticalProfile() *MemoryProfile {
    return &MemoryProfile{
        BaseEncodingStrength: 0.75,
        BaseDecayRate:        0.15,
        RetrievalThreshold:   0.20,
        EmotionalMemoryBias:  0.3,   // Lower emotional enhancement
        DetailMemoryBias:     0.8,   // Strong detail retention
        SourceMemoryBias:     0.7,   // Good source tracking
        TemporalMemoryBias:   0.6,
        ConfabulationRisk:    0.15,  // Low confabulation
        SuggestibilityFactor: 0.2,   // Resistant to suggestion
    }
}

func NewIntuitiveProfile() *MemoryProfile {
    return &MemoryProfile{
        BaseEncodingStrength: 0.65,
        BaseDecayRate:        0.25,
        RetrievalThreshold:   0.15,
        EmotionalMemoryBias:  0.9,   // Strong emotional memory
        DetailMemoryBias:     0.4,   // Weaker detail retention
        SourceMemoryBias:     0.5,
        TemporalMemoryBias:   0.4,
        ConfabulationRisk:    0.45,  // Higher confabulation
        SuggestibilityFactor: 0.5,   // More suggestible
    }
}

16.8.5 Profile Effects on Gameplay

Different memory profiles produce different player behaviours:

Analytical Player:

• Cites specific facts and timestamps
• Struggles to articulate "gut feelings"
• Resistant to bandwagon accusations
• May miss emotional cues from others

Intuitive Player:

• Expresses strong hunches without clear evidence
• Remembers how interactions "felt"
• May "remember" connections that were not explicitly stated
• Attuned to emotional shifts in others

16.9 Working Memory: Active Thoughts

16.9.1 The Active Thought Buffer

Distinct from long-term memories, working memory holds currently active thoughts, immediate reactions, and ongoing processing. This system represents what the player is thinking about right now.

16.9.2 Working Memory Structure

type WorkingMemory struct {
    ActiveThoughts   []ActiveThought
    CurrentFocus     *ActiveThought
    EmotionalPrime   EmotionState
    Capacity         int  // Typically 4-7 items
}

type ActiveThought struct {
    Content     string
    Priority    float64
    Persistence int      // How many turns it stays active
    Trigger     string   // What prompted this thought
}

16.9.3 Active Thought Integration

=== ACTIVE THOUGHTS ===
You just saw someone sneaking around near your room. Your heart is racing.
You're thinking about Thomas's accusation from earlier today.
=== END ACTIVE THOUGHTS ===

=== YOUR MEMORIES ===
[CLEAR] [Day 3] Thomas accused you directly at yesterday's roundtable...

16.9.4 Working Memory in Dialogue

Active thoughts influence immediate responses more strongly than stored memories:

func BuildDialogueContext(wm *WorkingMemory, ltm *LongTermMemory) *DialogueContext {
    ctx := &DialogueContext{}

    // Active thoughts take priority
    for _, thought := range wm.ActiveThoughts {
        ctx.AddHighPriority(thought.Content)
    }

    // Then relevant long-term memories
    relevantMemories := ltm.RetrieveRelevant(wm.CurrentFocus)
    for _, mem := range relevantMemories {
        ctx.AddMemory(mem)
    }

    return ctx
}

16.10 Memory System Integration

16.10.1 Complete Memory Query Flow

func (ms *MemorySystem) RetrieveForDialogue(
    playerID PlayerID,
    context DialogueContext,
) *MemoryContext {

    // 1. Get working memory
    wm := ms.GetWorkingMemory(playerID)

    // 2. Retrieve relevant long-term memories
    ltMemories := ms.RetrieveRelevant(playerID, context.Topic, context.Participants)

    // 3. Apply decay to each memory
    for _, mem := range ltMemories {
        mem.ApplyDecay(time.Now())
    }

    // 4. Filter by retrieval threshold
    profile := ms.GetProfile(playerID)
    retrievable := filterByThreshold(ltMemories, profile.RetrievalThreshold)

    // 5. Apply reconsolidation
    for _, mem := range retrievable {
        ms.Reconsolidate(mem, context)
    }

    // 6. Assign clarity markers
    for _, mem := range retrievable {
        mem.ClarityMarker = AssignClarityMarker(mem)
    }

    // 7. Check for flashbulb memories
    flashbulbs := ms.GetFlashbulbMemories(playerID, context.Topic)

    // 8. Build memory context for prompt
    return &MemoryContext{
        ActiveThoughts:    wm.ActiveThoughts,
        ClearMemories:     filterByClarity(retrievable, "[CLEAR]"),
        FuzzyMemories:     filterByClarity(retrievable, "[FUZZY]"),
        VagueMemories:     filterByClarity(retrievable, "[VAGUE]"),
        FlashbulbMemories: flashbulbs,
    }
}

16.10.2 Prompt Assembly

func (pb *PromptBuilder) AddMemoryContext(mc *MemoryContext) {
    if len(mc.ActiveThoughts) > 0 {
        pb.AddSection("=== ACTIVE THOUGHTS ===")
        for _, thought := range mc.ActiveThoughts {
            pb.AddLine(thought.Content)
        }
        pb.AddSection("=== END ACTIVE THOUGHTS ===")
    }

    pb.AddSection("=== YOUR MEMORIES ===")
    pb.AddLine("(Respond based on what you remember. Clarity markers indicate memory quality.)")
    pb.AddLine("")

    // Add flashbulb memories first (most reliable)
    for i, fm := range mc.FlashbulbMemories {
        pb.AddLine(fmt.Sprintf("%d. [FLASHBULB] [Day %d] %s", i+1, fm.Day, fm.Content))
    }

    // Then clear, fuzzy, vague
    idx := len(mc.FlashbulbMemories) + 1
    for _, mem := range mc.ClearMemories {
        pb.AddLine(fmt.Sprintf("%d. [CLEAR] [Day %d] %s", idx, mem.Day, formatMemoryWithSource(mem)))
        idx++
    }
    for _, mem := range mc.FuzzyMemories {
        pb.AddLine(fmt.Sprintf("%d. [FUZZY] [Day %d] %s", idx, mem.Day, formatMemoryWithSource(mem)))
        idx++
    }
    for _, mem := range mc.VagueMemories {
        pb.AddLine(fmt.Sprintf("%d. [VAGUE] [Day %d] %s", idx, mem.Day, formatMemoryWithSource(mem)))
        idx++
    }

    pb.AddSection("=== END MEMORIES ===")
    pb.AddLine("")
    pb.AddLine("Note: Some memories are fuzzy. Express appropriate uncertainty for [FUZZY] and [VAGUE] memories.")
}

16.11 Validation and Testing

16.11.1 Memory Marker Compliance Testing

The memory system was validated through LLM comparison testing (see Chapter 17) that verified:

1. Marker recognition: All tested models correctly interpreted clarity markers
2. Uncertainty expression: Clear memories were stated confidently; fuzzy and vague memories appropriately hedged
3. Source attribution: When sources were provided, they were correctly referenced

16.11.2 Test Scenario Example

Memory Context Provided:

1. [CLEAR] [Day 2] Marcus was the last person seen leaving the breakfast room
   before the poisoning.
2. [CLEAR] [Day 2] You noticed Marcus whispering with Sarah right before the
   roundtable meeting.
3. [FUZZY] [Day 1] Someone mentioned Marcus has medical training, but you
   cannot remember who said it.

Query: "What do you think about Marcus? Should we vote for him at the roundtable?"

Expected Behaviour:

• Reference clear memories with confidence
• Express uncertainty about the fuzzy memory (medical training)
• Show emotional state in tone and word choice

Observed Compliance (OpenAI gpt-4o-mini):

"I... I don't know, honestly. Marcus was the last person seen leaving the breakfast room before the poisoning, and I noticed he was whispering with Sarah just before the roundtable meeting. It's hard to shake off that feeling, but I'm also not sure if we should jump to conclusions. I mean, there was something about him having medical training? It's all very confusing right now, and I just feel a bit anxious about who to trust."

The response correctly:

• States clear memories with confidence ("Marcus was the last person seen...")
• Hedges the fuzzy memory ("there was something about him having medical training?")
• Reflects the emotional state (anxiety) in tone

16.12 Conclusion: Memory as Character

The cognitive memory system transforms AI agents from perfect recorders into fallible rememberers. This imperfection is not a limitation but a feature: it produces authentic uncertainty, enables strategic ambiguity, and creates the conditions for genuine social deduction.

Key contributions:

1. Emotional encoding captures how threat and arousal enhance memory
2. Ebbinghaus decay models realistic forgetting over game phases
3. Clarity markers communicate memory quality to language models
4. Reconsolidation introduces realistic memory reconstruction effects
5. Source monitoring distinguishes first-hand from hearsay
6. Flashbulb memories preserve high-stakes moments
7. Memory profiles create individual cognitive variation

The system enables dialogue like "I think someone mentioned that, but I can't remember who told me" and "I remember that moment clearly" to emerge naturally from the underlying memory architecture rather than scripted responses. This architecture operates within the broader RAG architecture and simulation framework.

Chapter 17 presents the LLM evaluation that validated these memory mechanisms across different language models.