🔗 Synapse — Tags & Scoring¶

Biological Analog: In neuroscience, the Synaptic Tagging and Capture (STC) hypothesis (Frey & Morris, 1997) describes how synapses are "tagged" during learning with lightweight chemical markers. These tags don't contain the memory itself — they identify what the memory is about and when it was formed, enabling the brain to route consolidation activity efficiently.

Header Layout — 64-Byte Cache-Line Format¶

Every cognitive memory record begins with a synaptic header — the digital equivalent of a synaptic tag. The format is defined by the HeaderLayout sealed interface with a single implementation: HeaderLayout64.

Layout (64 bytes) — Cache-Line Aligned¶

The sole header layout, aligned to a full CPU cache line (64 bytes) for optimal sequential scan performance.

 Offset   Size   Field              Description
 ──────   ────   ─────              ───────────
    0      1B    header_version     Always 1
    1      1B    flags              Tombstone, type, consolidated, pinned, resolved
    2      1B    valence            Emotional coloring (signed: -128 to +127)
    3      1B    arousal            Emotional intensity (unsigned: 0-255)
    4      4B    importance         Base importance score (0.05 – 10.0)
    8      8B    timestamp_ms       Unix epoch ms when memory was formed
   16      4B    agent_recall_count LTP reinforcement counter
   20      4B    exact_norm         L2 norm of original float vector
   24      8B    synaptic_tags      64-bit Bloom filter of contextual markers
   32      2B    centroid_id        IVF partition routing ID
   34      2B    _pad0              Alignment padding
   36      4B    storage_strength   Two-Factor Memory S(t) (Bjork & Bjork)
   40      4B    spector_recall_cnt Auto-LTP passive counter
   44      4B    _reserved_f1       Future float
   48      8B    last_auto_ltp      Auto-LTP timestamp
   56      8B    _reserved_l1       Future (128-bit tag upper half)
                                    ═══════════════════════════════════
                                    Total: 64 bytes (1× cache line, 2× AVX2)

Memory Cost¶

Flags Bitfield¶

The flags byte at offset 1 encodes per-record state:

 Bit   Name          Description
 ───   ────          ───────────
  0    tombstone     Record is logically deleted (pruned by Deep Sleep)
  1-2  memory_type   2-bit type: 0=WORKING, 1=EPISODIC, 2=SEMANTIC, 3=PROCEDURAL
  3    consolidated  Has been reflected into Semantic tier
  4    pinned        Exempt from decay and pruning (flashbulb memories)
  5    resolved      Zeigarnik Effect — resolved tasks return to normal decay
  6-7  reserved      Future use

Zeigarnik Effect (Bit 5)¶

Unresolved memories (bit 5 = 0) resist time-decay — their decay bucket is clamped to 0, keeping them perpetually "fresh." This models the psychological phenomenon where incomplete tasks remain more accessible than completed ones. Once the agent marks a task complete, bit 5 is set to 1 and normal decay resumes.

SynapticTagEncoder — The Inline Bloom Filter¶

The synaptic_tags field is a 64-bit inline Bloom filter rather than a discrete bitmap. This enables encoding thousands of unique tag strings across the system while each individual record holds 5-50 tags with negligible false positive rates.

How It Works¶

Each tag string is hashed via double hashing (MurmurHash3-inspired) to produce k=3 bit positions within the 64-bit filter. The match operation is a single bitwise AND: (record & query) == query.

Key properties:

False Positive Rates¶

Tag Overlap Scoring¶

Beyond binary gating, the tag encoder computes a fractional overlap ratio for weighted tag relevance:

This ratio is used as a multiplier in the scoring formula: finalScore = baseScore × (1 + tagOverlap × tagRelevanceBoost). A record matching 3 of 5 query tags gets a 60% tag boost vs 100% for a full match.

CognitiveRecordLayout — Binary Format¶

The record layout manages reading/writing headers and quantized vectors to/from off-heap memory. Each record is: 64-byte header + N-byte quantized vector.

Record stride = 64B header + quantized vector bytes
Example (768-dim INT8): stride = 64 + 768 = 832 bytes

CognitiveHeader Fields¶

DecayStrategy — SIMD-Friendly Temporal Decay¶

The Solution: Power-Law Decay Buckets¶

The decay strategy quantizes time into 12 discrete buckets spanning 5+ years and uses precomputed lookup tables derived from the power law of forgetting:

Bucket values are generated at startup from DecayConfig, not hardcoded — making the decay curve fully configurable.

12-Bucket Time Ranges¶

DecayConfig Presets¶

Three presets are available for different agent personalities:

Reconsolidation Adjustment (LTP)¶

Each recall effectively halves the memory's perceived age by bit-shifting the bucket index right. This mirrors biological spaced repetition where each successful retrieval doubles the memory's half-life:

A memory recalled 3 times is 8× "younger" than its actual age — it powerfully resists forgetting.

Auto-LTP (Passive Recall)¶

Spector also tracks internal passive recalls separately from agent-explicit reinforcement. Passive recall uses a gentler linear shift capped at 2 buckets — preventing passive retrieval from making memories artificially immortal.

Arousal-Modulated Decay¶

Emotionally intense memories resist forgetting. The arousal byte modulates the decay curve through a 4-entry lookup table:

The modifier multiplies the base decay factor, slowing the decay rate. A production outage at arousal=200 decays 1.65× slower than a routine log entry at arousal=0.

Automatic arousal derivation: When arousal is not explicitly set by the LLM, it is auto-derived from valence at ingestion time:

This means both extremely positive (valence=+100) and extremely negative (valence=-100) memories are equally arousing — matching the psychological finding that emotional intensity, not polarity, drives memory persistence.

Next Steps¶

• Dopamine — Surprise Detection — auto-importance scoring
• Cortex — Tier Stores — the 4-tier architecture
• 6-Phase Scoring Pipeline — how scoring uses the header
• Labs — Research Roadmap — Two-Factor Memory, Dynamic Quantization