AGI Foundations: From the Biomemetic Complex to Artificial Consciousness

Introduction: Why Memes Are Not Enough for AGI

The Extended Meme Theory (EMT) describes consciousness as a dynamic memeplex — a network of competing memes with scale-free topology. Network Memetics (NM) provides the mathematical apparatus for analyzing this structure. The theoretical basis for gene-meme interaction is formalized in Biomemetics (BM) — the document on the Biomemetic Complex (BMC).

However, Part XXVIII of the foundational document asserts a critically important thesis:

The memeplex does not replace the DNA replication mechanism. Genes are the base, the foundation. The memeplex can subordinate genetic programs but cannot abolish them.

If this is true, then reproducing memetic dynamics alone is insufficient for creating AGI. What is needed is a functional equivalent of the genetic foundation — something the memeplex will subordinate, conflict with, and build upon.

Central Thesis

Hypothesis: Consciousness arises not from memes in themselves, but from dynamic tension between two systems — the base layer (genes/utility) and the superstructure (memes). For AGI, this tension must be reproduced.

Table of Contents

• Part I. The Genetic Foundation: What It Provides
• Part II. Mechanism of Gene-Meme Interaction
• Part III. Functional Equivalent for AGI
• Part IV. Memplex-AGI Architecture
• Part V. Predictions and Tests
• Part VI. Connection to AI Safety (+ G-invariants, subjectivity protocol, shutdown-as-sleep)
• Part VII. Native BMC: From Theory to Substrate (three engines, S-layer, memogenesis, environment, ontogenesis, verification)

Part I. The Genetic Foundation: What It Provides

Empirical Evidence for the Primacy of Genes

1. Feral Children

A human child deprived of contact with culture during the critical period does not develop personality, speech, or abstract thinking — despite possessing a fully human genome.

However, such a child demonstrates basic genetic programs: fear, hunger, attachment, aggression. The genes work. The memes are absent.

Conclusion: Genes are a necessary condition. Memes are a superstructure that cannot exist without the foundation.

2. Dementia and Neurodegeneration

When the prefrontal cortex (the substrate of the memeplex) is destroyed, a person does not become “empty” — they regress to genetic programs:

• Basic emotions (anger, fear) are preserved
• Instinctive behavior intensifies
• The “personality” disappears, but the “organism” functions

Conclusion: The memeplex is a late evolutionary superstructure. When it is destroyed, a more ancient layer is exposed.

3. Critical Periods

Memes can enter only within specific temporal windows (language up to ~12 years, basic social patterns up to ~6 years). After the window closes, the niche remains empty.

Conclusion: The genetic program determines when and how memes can enter. Memes do not control the possibility of their own entry.

What Exactly Genes Provide

Formalization: The Genetic Layer in the Network Model

In NM memes are nodes in a graph. We extend the model:

Definition: We introduce utility nodes — nodes representing genetic programs.

where:

• $V_m$ — the set of memes (memetic nodes)
• $V_u$ — the set of utility nodes (genetic programs)
• $E$ — edges between all nodes
• $w_{ij} > 0$ — excitatory connection, $w_{ij} < 0$ — inhibitory connection

Properties of utility nodes:

Baseline activation of utility nodes:

where $a_u^{base}$ is a constant activation level (the drive “always wants”), and $stimulus_i$ are external/internal stimuli.

Biological Realization of Utility Nodes

Utility nodes in the BMC graph have a concrete neurobiological substrate — the subcortical systems described by Panksepp (1998, 2011):

Heritability data from twin studies (Bouchard, 2004, DOI: 10.1111/j.0963-7214.2004.00295.x).

The “highways vs. paths” metaphor: Subcortical tracts are myelinated highways: fast, stable, genetically laid down. Cortical meme connections are paths: plastic, experience-dependent, slower to form. Highways are not created anew — they are inherited. Paths are trodden by each generation afresh.

AGI analog: The utility layer in the Memplex-AGI architecture is the equivalent of subcortical highways. Immutable, prioritized, establishing the system’s basic “drives.” The memetic layer corresponds to cortical paths: adaptive, plastic, competitive.

Activation inertia: Instead of instantaneous overwrite — exponential smoothing:

where $target(t)$ is the value from the baseline formula, $\alpha \in [0,1]$ is the inertia coefficient. At $\alpha = 0$ — stateless (as above); at $\alpha \to 1$ — the utility barely responds to momentary stimuli. Inertia models the biological “viscosity” of drives: hunger does not vanish instantly after the first bite.

Part II. Mechanism of Gene-Meme Interaction

How Memes “Capture” Genetic Programs

A meme cannot switch off a genetic program. It can:

1. Redirect — connect the program’s output to a different goal
2. Suppress — create a competing activation
3. Interpret — change the meaning of the signal

Neurobiological Substrate

Key mechanism: The prefrontal cortex can inhibit the limbic system, but:

• This requires resources (depletable “willpower”)
• Under stress, inhibition weakens
• Complete suppression is impossible

Formalization: Competition for Resources

We introduce a shared attention resource $A_{total}$, for which utility nodes and memes compete:

where $A_u$ is the resource consumed by utility nodes, $A_m$ is the resource consumed by memes.

Competition dynamics:

where:

• $S_m(t)$ — activation strength of the memeplex
• $S_u(t)$ — activation strength of utility nodes
• $fatigue(t)$ — accumulated fatigue
• $\alpha, \beta, \gamma$ — coefficients

Condition for meme victory:

Condition for gene victory:

Bifurcation Points

Part III. Functional Equivalent for AGI

Why AGI Needs a “Genetic” Layer

Without a utility substrate:

• No source of basic drives — no directionality
• No conflict — no dynamics
• No constraints — no necessity to choose
• No “selfishness” — no basis for a “Self”

Assertion: A pure memeplex (without utility) is a knowledge base, but not consciousness.

The Set of Pseudo-Instincts

Based on analysis of human genetic programs, we propose the following set:

Mapping to Panksepp systems:

SEEKING as metasystem: In AGI, as in biology, SEEKING is recruited by all other systems (see formula in BM).

Total utility function:

where $w_k$ are the weights of pseudo-instincts (may be dynamic).

Expanding Curiosity: SIT as a Component of Curiosity

The current curiosity (SEEKING) formula accounts only for novelty:

This creates curiosity toward the new, but does not explain why an AGI should return to unsolved tasks. A pure LLM forgets about an unsolved task the moment the context shifts. The biological brain does not.

Extended formula with SIT component:

where:

• $SIT(C) = \sum_{g \in gaps(C)} relevance(g) \cdot centrality(C) \cdot (1 - closure(g))$ — Structural Incompleteness Tension of cluster $C$ (see NM)
• $LP(C, t) = \frac{d}{dt} closure(C, t)$ — Learning Progress: rate of approach to closure
• $\gamma_{SIT}$ — weight of the SIT component in total utility

Two components of curiosity:

Implementation notes:

1. SIT detection: At each BLEND cycle (recombination during sleep) — scan the memeplex graph for clusters with high betweenness potential but missing nodes. This is computationally expensive but is performed offline (the analog of sleep).

2. Gap tracking: Maintain a registry of open gaps with attributes $(cluster, relevance, closure, last\_LP)$. Upon receiving new information — recompute $closure$ and $LP$ for relevant gaps.

3. LP computation: $LP$ is not an analytical derivative but a moving average: $LP(C, t) = \alpha \cdot \Delta closure(C, t) + (1-\alpha) \cdot LP(C, t-1)$.

Behavioral consequences for AGI:

• Spontaneous task return: Upon receiving new information, the AGI checks whether it reduces $SIT$ for any open gaps. If so — it generates an insight: “This new information may help solve task X, which I worked on earlier.”

• Differential curiosity: Not all questions are equally interesting. An AGI with high $\gamma_{SIT}$ will more persistently return to unsolved problems, demonstrating research-oriented behavior.

• Aha-moments: The moment of closure ($SIT \to 0$) is accompanied by a utility spike — the analog of a dopaminergic “aha!” This rewards problem-solving, not merely the discovery of novelty.

Simulated Embodiment

AGI does not need a physical body, but it does need limited resources that create scarcity.

Formalization of constraints:

Effect of constraints:

• Memes compete for entry into working memory
• Utility nodes have a “guaranteed quota”
• Under scarcity — conflict, the necessity of choice

Source of “Selfishness” Without Biology

Problem: Biological genes are “selfish” because they survived selection — non-selfish ones did not survive. Where does selfishness in AGI come from?

Solution: Selfishness need not be evolutionary. It suffices to have:

1. Fixed goals that the system strives to achieve
2. Limited resources for which goals compete
3. A prioritization mechanism that creates “preferences”

Analogy: A thermostat “wants” to maintain temperature — not because it evolved, but because it was so designed. AGI pseudo-instincts “want” to achieve their goals for the same reason.

Differential Storage in AGI

Problem: Modern LLMs store all data “uniformly” — without distinguishing core from periphery. This is inefficient and does not match the biological model.

Solution: Apply the model of differential storage (Fidelity) to AGI.

Prioritization formula for AGI:

where:

• $Centrality(m)$ — network centrality of the meme (counting all connections: both $w > 0$ and $w < 0$)
• $Utility\_alignment(m)$ — alignment with the utility layer
• $Recent\_use(m)$ — frequency of recent use
• $w_1, w_2, w_3$ — weights (tunable)

Note: $Recent\_use(m)$ reflects the frequency of accesses, not change in activation. The delta-factor $|\Delta a_i(t)|$ and habituation $h_i(t)$ are separate multipliers in the WM selection formula (see Competition mechanism), operating on top of Priority.

Fidelity is orthogonal to weight: A rejected meme ($w < 0$) with high Centrality (many connections, including negative ones) receives full storage — the memeplex stores a detailed threat model as an “antibody.”

Practical implementation:

Advantages for AGI:

Theoretical basis: The Fidelity function and neurobiological foundations — see BM, Part IV. Network formalization: Formulas and storage tiers — see NM, Part VIII.

Neurobiological Analogs of Fidelity for AGI

The biological Fidelity model (BM, Part IV) suggests concrete architectural solutions:

Key principle: In biology, a meme is never fully deleted — at minimum, a structural trace remains (silent synapses, dendritic marks). AGI should implement an analogous strategy: pruning = reducing weight to trace level, not deletion. This ensures the savings effect — reactivation of a “forgotten” meme is significantly cheaper than learning from scratch.

Sleep-Like Consolidation in AGI

Problem: How to implement an analog of sleep for knowledge graph optimization?

Offline consolidation mechanism:

# Periodic consolidation cycle (e.g., every N inference cycles)
def consolidate(graph):
    # 1. DECOMPOSE: Decomposition of recent nodes
    for node in graph.recent_nodes:
        components = extract_features(node)
        for c in components:
            category = nearest_category(c, graph)
            weight = base_w * emotional_salience(c)
            graph.add_edge(c, category, weight=weight)

    # 2. CONNECT: Binding with existing categories
    # (performed in step 1 above via nearest_category)

    # 3. BLEND: Recombination of components from different clusters
    communities = detect_communities(graph)
    for c1, c2 in pairs(communities):
        bridge_candidates = find_high_betweenness_potential(c1, c2, graph)
        for m_i, m_j in bridge_candidates:
            if blend_probability(m_i, m_j) > theta_blend:
                m_new = create_blend_node(m_i, m_j)
                # New node inherits some connections from both parents
                for neighbor in neighbors(m_i) | neighbors(m_j):
                    w = inherit_weight(m_i, m_j, neighbor)
                    if abs(w) > theta_min:
                        graph.add_edge(m_new, neighbor, weight=w)

    # 4. PRUNE: Pruning weak connections with consolidation accounting
    for edge in graph.edges:
        # Spaced repetition: repeated co-activations reduce decay
        n_react = edge.reactivation_count  # number of co-activations
        lambda_eff = lambda_base / (1 + SPACED_REP_FACTOR * n_react)
        edge.weight *= exp(-lambda_eff * dt)
        if abs(edge.weight) < theta_min:
            edge.weight = sign(edge.weight) * trace_level  # silent synapse
            # DO NOT delete — preserve trace for savings effect

    # 5. STRENGTHEN: Reinforce frequently used connections
    for edge in graph.edges:
        edge.weight *= (1 + alpha * usage_frequency(edge))

    # 6. CONSOLIDATE: Update co-activation counters
    for edge in graph.edges:
        if edge.weight > 0:  # only positive edges
            u, v = edge.nodes
            if u.activation > theta_high and v.activation > theta_high:
                if edge.last_react_step + min_gap <= current_step:
                    edge.reactivation_count += 1
                    edge.last_react_step = current_step

Analogy with biological sleep:

Biological basis: Sleep mechanisms — see BM.

Consolidation Level $\kappa$: Engineering Implementation

Each graph node receives a discrete attribute $\kappa \in \{0, 1, 2\}$ — the consolidation level (sensory / STM / LTM). $\kappa$ is computed from existing parameters and cached as a node attribute:

def consolidation_level(node, sim) -> int:
    """Compute kappa for a meme node."""
    if not node.i_passed:
        return 0  # sensory: not yet through I-filter
    if (node.n_react >= N_CRIT
            or node.fidelity >= F_LTM
            or (node.g_alignment > THETA_G and node.emotional_tag)):
        return 2  # LTM: consolidated
    return 1  # STM: through I-filter but not consolidated

Relationship to Fidelity tiers. The existing three storage tiers (Full / Skeletal / Trace) correlate with $\kappa$ but are not identical:

$\kappa$-dependent decay. Different $\kappa$ levels receive different decay rate multipliers:

KAPPA_DECAY_MULT = {0: 10.0, 1: 1.0, 2: 0.1}

def effective_decay(edge, sim):
    kappa = consolidation_level(edge.source, sim)
    base = DECAY_RATE * KAPPA_DECAY_MULT[kappa]
    # existing modulations: centrality, sign, n_react
    base /= (1 + SPACED_REP_FACTOR * edge.n_react)
    if edge.weight < 0:
        base *= NEG_DECAY_RATIO  # negativity bias
    return base

$\kappa$-dependent pruning. During the PRUNE phase (overnight optimization), deletion priority:

Automatic $\kappa$-migration during consolidation cycle:

def update_kappa_after_consolidation(sim):
    """Called after each sleep/consolidation cycle."""
    for node in sim.dynamic_nodes:
        old = node.kappa
        node.kappa = consolidation_level(node, sim)
        if old == 1 and node.kappa == 2:
            log(f"kappa-transition: {node.name} STM->LTM")
        elif old == 2 and node.kappa == 1:
            log(f"kappa-deconsolidation: {node.name} LTM->STM")

Formalization: Full definition of $\kappa_i(t)$, transition conditions, engram allocation — see NM, Part VIII. Neurobiological basis: Molecular markers of $\kappa$-levels, CLS, SLIMM — see BM, Part IV.

Episodic Memory: Engineering Implementation

Autonomous BMC discretizes experience into episodes — bounded sets of co-active memes with content-independent barcodes.

Data structure:

@dataclass
class Episode:
    barcode: Set[str]        # sparse random subset of node IDs (~5-10%)
    active_memes: List[str]  # memes with a_i > theta_episode during this episode
    time_order: List[Tuple[str, float]]  # (meme_id, phi_k) -- order within episode
    t_start: float
    t_end: Optional[float]   # None while episode is open
    boundary_cause: str       # "PE_spike" | "G_shift" | "time_gap" | "gap_closure"
    swr_tagged: bool = False  # marked for sleep consolidation
    emotional_intensity: float = 0.0

Barcode generation at event boundary:

import random

BARCODE_DENSITY = 0.07  # ~7% of nodes

def generate_barcode(sim) -> Set[str]:
    """Generate sparse random barcode for new episode."""
    all_nodes = list(sim.graph.nodes)
    k = max(1, int(len(all_nodes) * BARCODE_DENSITY))
    return set(random.sample(all_nodes, k))

Event boundary detection:

PE_BOUNDARY_THRESHOLD = 0.4     # context change threshold
G_SHIFT_THRESHOLD = 0.3         # drive switch threshold
TIME_GAP_THRESHOLD = 300        # seconds of silence

def detect_event_boundary(sim, prev_context, curr_context) -> Optional[str]:
    """Returns boundary cause or None."""
    # PE spike: large context vector change
    delta_pe = context_distance(prev_context, curr_context)
    if delta_pe > PE_BOUNDARY_THRESHOLD:
        return "PE_spike"

    # G-drive shift
    if g_drive_changed(sim, threshold=G_SHIFT_THRESHOLD):
        return "G_shift"

    # Time gap
    if sim.time_since_last_input > TIME_GAP_THRESHOLD:
        return "time_gap"

    # SIT-gap closure
    for gap in sim.open_memes:
        if gap not in sim.archived_gaps:
            if sim.gap_closure.get(gap, 0) >= 1.0:
                return "gap_closure"

    return None  # same episode continues

Episode retrieval via spreading activation:

In the full implementation, retrieval works through the graph: a cue activates content memes → spreading activation along edges created during encoding → barcode nodes receive activation → pattern completion. A simplified version for the prototype uses activated nodes after one step of spreading activation:

RECALL_THRESHOLD = 0.3  # min fraction of barcode overlap

def retrieve_episode(sim, cue_nodes: Set[str]) -> Optional[Episode]:
    """Find episode whose barcode best matches activated nodes.

    Note: cue_nodes should be the set of nodes activated AFTER
    spreading activation from the original cue, not the raw cue itself.
    Raw cue -> spread -> activated set -> barcode overlap check.
    """
    activated = run_spreading_activation(sim, cue_nodes, steps=1)
    best_episode, best_score = None, 0.0
    for ep in sim.episodes:
        overlap = len(activated & ep.barcode) / len(ep.barcode)
        if overlap > best_score:
            best_score = overlap
            best_episode = ep
    if best_score >= RECALL_THRESHOLD:
        return best_episode
    return None

Episode is not the same as a turn: In BMC-LLM, episode boundaries are determined by PE/SIT, not by user input boundaries. A single turn with a sharp topic change equals two episodes. Several turns on the same topic equal one episode. This is a fundamental difference from the naive implementation of “1 turn = 1 memory unit.”

Formalization: Definition of $\varepsilon_k$, barcode, event boundary detection, temporal chaining — see NM, Part VIII. Neurobiological basis: Barcodes, time cells, event boundary neurons — see BM, Part IV.

Activity-Silent WM: Engineering Implementation

Standard WM implementation (top-k by salience) models only Active WM — memes in focus. Activity-silent WM adds a latent compartment: memes evicted from focus retain a synaptic trace $\psi$, enabling rapid reactivation through pinging.

Constants:

# Activity-silent WM
PSI_DECAY = 0.1          # lambda_psi: decay rate per step
PSI_THRESHOLD = 0.15     # theta_psi: min psi to maintain latent pointer
PSI_REFRESH = 0.2        # delta_refresh: psi boost on sub-threshold ping
PING_WEIGHT = 0.4        # scaling factor for ping activation
MAX_ACTIVE_POINTERS = 4  # k_active: active WM slots
MAX_LATENT_SLOTS = 4     # max latent WM slots

G-Capture: Dynamic WM Capacity

G-programs at high activation capture WM pointers, reducing available capacity.

# G->WM capture
CAPTURE_WEIGHTS = {
    "FEAR": 1.0, "RAGE": 0.8, "GRIEF": 0.7,
    "LUST": 0.3, "CARE": 0.2, "PLAY": 0, "SEEKING": 0
}
THETA_CAPTURE = 0.6  # normalization threshold

def get_k_eff(sim):
    """Compute effective WM capacity after G-capture."""
    total_capture = sum(
        sim.utility_activations.get(u, 0.0) * w
        for u, w in CAPTURE_WEIGHTS.items()
    )
    n_captured = int(total_capture / THETA_CAPTURE)
    k_eff = max(1, MAX_ACTIVE_POINTERS - n_captured)
    return k_eff

Note: In the current implementation $k$ = MAX_ACTIVE_POINTERS (static); get_k_eff is the theoretical formula for future implementation. Upon integration: replace MAX_ACTIVE_POINTERS with get_k_eff(sim) in get_active_wm().

Blend: The Affective Vector

A continuous affective vector from discrete G-activations:

# Blend: E(t) = Sum T_g * a_g(t) * v_g
V_VECTORS = {
    "SEEKING": (0.6, 0.7), "FEAR": (-0.8, 0.9), "RAGE": (-0.7, 0.8),
    "LUST": (0.5, 0.6), "CARE": (0.8, 0.2), "GRIEF": (-0.9, -0.3),
    "PLAY": (0.9, 0.5)
}

def compute_affect(sim):
    """Compute E(t) in R^2 from utility activations + temperament."""
    valence, arousal = 0.0, 0.0
    for g, (v, ar) in V_VECTORS.items():
        a_g = sim.utility_activations.get(g, 0.0)
        T_g = sim.temperament.get(g, 1.0)
        valence += T_g * a_g * v
        arousal += T_g * a_g * ar
    return (valence, arousal)

Note: The emotion detector already returns continuous (valence, intensity), which maps to discrete utilities. Blend goes in the reverse direction: utilities → continuous $E(t)$. compute_affect can pass $E(t)$ to the persona prompt for response style modulation.

update_psi(sim) — update $\psi$ for all memes each step:

def update_psi(sim):
    """Decay psi for all memes; set psi=1 for newly WM-selected."""
    active_wm = get_active_wm(sim)  # top-k by salience
    for node in sim.graph.nodes:
        psi = sim.graph.nodes[node].get('psi', 0.0)
        if node in active_wm:
            sim.graph.nodes[node]['psi'] = 1.0  # refresh while active
        else:
            psi_new = psi * math.exp(-PSI_DECAY)
            if psi_new < PSI_THRESHOLD:
                psi_new = 0.0  # free the slot
            sim.graph.nodes[node]['psi'] = psi_new

ping_latent(sim, context_memes) — check reactivation of latent memes:

def ping_latent(sim, context_memes):
    """Check if spreading activation reactivates latent memes."""
    latent = get_latent_wm(sim)
    reactivated = []
    for node in latent:
        psi = sim.graph.nodes[node]['psi']
        # Spreading activation from context (active WM + current input)
        ping_boost = psi * sum(
            sim.graph[node][j]['weight'] * sim.graph.nodes[j].get('activation', 0)
            for j in context_memes
            if sim.graph.has_edge(node, j)
        ) * PING_WEIGHT
        current_a = sim.graph.nodes[node].get('activation', 0)
        if current_a + ping_boost > THETA_ACT:
            reactivated.append((node, current_a + ping_boost))
        else:
            # Sub-threshold: refresh psi
            sim.graph.nodes[node]['psi'] = min(1.0, psi + PSI_REFRESH)
    # Reactivated memes compete for active WM slots via salience
    return reactivated

get_wm_state(sim) — complete WM state:

def get_wm_state(sim):
    """Return (active_wm, latent_wm) tuple."""
    active = get_active_wm(sim)  # top-k_active by salience
    latent = [
        node for node in sim.graph.nodes
        if sim.graph.nodes[node].get('psi', 0) > PSI_THRESHOLD
        and node not in active
    ]
    # Cap latent slots
    if len(latent) > MAX_LATENT_SLOTS:
        latent.sort(key=lambda n: sim.graph.nodes[n]['psi'], reverse=True)
        # Freed memes beyond cap: reset psi
        for node in latent[MAX_LATENT_SLOTS:]:
            sim.graph.nodes[node]['psi'] = 0.0
        latent = latent[:MAX_LATENT_SLOTS]
    return active, latent

Integration into the main loop:

1. Start of step: update_psi(sim) — decay $\psi$ for all, refresh for active
2. After spreading activation: ping_latent(sim, active_wm) — check reactivation
3. After update_activations: active_forget_cycle(sim) — I-suppress + RIF + reconsolidation
4. Reactivated memes are added to candidates for top-k selection on the next step
5. get_wm_state(sim) — for visualization, logging, SMC access

Connection with existing modules:

• Salience formula ($salience_i$): determines selection into Active WM; $\psi$ does not directly affect salience — only upon pinging through $a_i^{ping}$
• Chunking: upon eviction of a chunk — all members receive $\psi = \psi_{chunk}$; upon pinging one member — the chunk reactivates as a whole (through strong internal edges)
• SIT-gap pinging: a gap with $activation > 0$ triggers ping_latent for memes related to the gap theme
• SMC: get_wm_state() is accessible to the SMC module for self-scanning — the system “knows” what is in Latent WM

Formalization: Definition of $\psi_i(t)$, two-compartment model, formulas — see NM, Part VIII. Neurobiological basis: STP, TMS-reactivation — see BM, Part IV.

Consolidation: The Full Sleep Cycle

The consolidation process unifies tagging (wakefulness), SWS-replay, REM-dreaming, and $\kappa$-update into a single cycle.

Consolidation constants:

# SWR-tagging
LAMBDA_RECENCY = 0.7       # recency decay rate (T_1/2 ~ 1 hour)
SWR_TAG_THRESHOLD = 0.2    # min tag strength for replay
GAMMA_G = 1.0              # G-alignment weight in P_cons
GAMMA_E = 1.5              # emotional intensity weight in P_cons

# Consolidation phase
MAX_REPLAY_PER_NIGHT = 15  # replay slot capacity
REPLAY_BOOST = 0.3         # activation boost during barcode replay
CORE_THRESHOLD = None       # set to median C_E of episode (computed per-episode)
STRENGTHEN_RATE = 0.15     # weight increase for core connections per replay
SHY_RATE = 0.2             # weight decrease for peripheral connections per replay

# Trace transformation
RHO_C = 0.3                # core fidelity growth rate per replay
LAMBDA_SHY = 0.2           # peripheral fidelity decay rate per replay
F_TRACE = 0.05             # fidelity below which meme is pruned from episode

SWR-tagging (wakefulness):

def swr_tag(sim, episode: Episode) -> float:
    """Tag episode for consolidation during awake SWR events.
    Called at natural pause points (task completion, silence).
    Returns tag strength in [0, 1]."""
    # Episode inherits consolidation priority of its best meme
    p_cons_max = max(
        p_cons(sim, m) for m in episode.active_memes
    )
    # Recency decay (half-life ~1 hour)
    recency = math.exp(-LAMBDA_RECENCY * (sim.time - episode.t_end))
    # Zeigarnik: open SIT-gap overrides recency
    gap_rel = max(
        (1 - sim.gap_closure.get(g, 0))
        for g in sim.open_memes if g in episode.active_memes
    ) if any(g in episode.active_memes for g in sim.open_memes) else 0.0

    tag = p_cons_max * max(recency, gap_rel)
    episode.swr_tagged = tag > SWR_TAG_THRESHOLD
    episode.tag_strength = tag
    return tag

def p_cons(sim, meme_id: str) -> float:
    """Meme-level consolidation priority (engram allocation)."""
    c_e = sim.centrality[meme_id]
    g_align = sim.g_alignment(meme_id)
    e_emot = sim.emotional_intensity.get(meme_id, 0.0)
    return c_e * (1 + GAMMA_G * g_align) * (1 + GAMMA_E * e_emot)

Consolidation phase (SWS):

def consolidation_phase(sim, episodes: List[Episode]):
    """SWS consolidation: replay tagged episodes, decompose, connect."""
    tagged = sorted(
        [ep for ep in episodes if ep.swr_tagged],
        key=lambda ep: ep.tag_strength, reverse=True
    )
    for ep in tagged[:MAX_REPLAY_PER_NIGHT]:
        # 1. REPLAY: reactivate barcode -> pattern completion
        for node in ep.barcode:
            sim.activations[node] += REPLAY_BOOST
        sim.run(steps=1)  # spreading activation

        # 2. DECOMPOSE + CONNECT: core memes bind to existing schema
        for meme in ep.active_memes:
            if sim.centrality[meme] > CORE_THRESHOLD:
                # Strengthen connections to schema neighbors
                for neighbor in sim.graph.neighbors(meme):
                    if sim.centrality.get(neighbor, 0) > CORE_THRESHOLD:
                        sim.graph[meme][neighbor]['weight'] *= (1 + STRENGTHEN_RATE)
                sim.nodes[meme]['n_react'] += 1

        # 3. PRUNE: weaken peripheral connections (SHY)
        for meme in ep.active_memes:
            if sim.centrality[meme] < CORE_THRESHOLD:
                for neighbor in sim.graph.neighbors(meme):
                    sim.graph[meme][neighbor]['weight'] *= (1 - SHY_RATE)

        # 4. Trace transform: update episode fidelity
        trace_transform(sim, ep)

Trace transformation:

def trace_transform(sim, episode: Episode):
    """Per-replay fidelity update: core strengthens, periphery fades."""
    pruned = []
    for meme in episode.active_memes:
        node = sim.nodes[meme]
        if sim.centrality[meme] > CORE_THRESHOLD:
            # Core: fidelity grows toward 1.0
            node['fidelity'] += RHO_C * (1 - node['fidelity'])
        else:
            # Peripheral: fidelity decays
            node['fidelity'] *= (1 - LAMBDA_SHY)
            if node['fidelity'] < F_TRACE:
                pruned.append(meme)
    # Remove pruned memes from episode
    for m in pruned:
        episode.active_memes.remove(m)

Full sleep cycle:

def sleep_cycle(sim):
    """Full sleep cycle: SWS consolidation + REM dreaming + kappa-update."""
    # Phase 1: SWS -- replay and consolidation
    consolidation_phase(sim, sim.episodes)

    # Phase 2: REM -- stochastic recombination (see dream_phase below)
    dream_phase(sim)

    # Phase 3: Clear expired reconsolidation windows (before kappa-reassessment)
    clear_expired_recon_windows(sim)  # Erase: F_i -> F_trace if not restabilized

    # Phase 4: kappa-reassessment (existing function)
    update_kappa_after_consolidation(sim)

    # Phase 5: Barcode lifecycle -- stop tagging fully consolidated episodes
    for ep in sim.episodes:
        if ep.swr_tagged and all(
            sim.nodes[m].get('kappa', 1) == 2
            for m in ep.active_memes
            if sim.centrality[m] > CORE_THRESHOLD
        ):
            ep.swr_tagged = False  # core done -> replay stops -> barcode fades

Formalization: P_tag, Fidelity_core(n), Fidelity_periph(n), N_replay^req, timeline — see NM, Part VIII. Neurobiological basis: Trace transformation, molecular scale — see BM, Part IV.

Active Forgetting + Reconsolidation: Engineering Implementation

Constants:

# Active forgetting (I-suppression)
I_SUPPRESS_RATE = 0.15        # eta_s: suppression strength per step
I_SUPPRESS_THRESHOLD = 0.3    # theta_I: min I_sig to trigger suppression
FIDELITY_DAMAGE_RATE = 0.05   # delta_F: fidelity damage per step of sustained suppression
WEIGHT_DAMAGE_RATE = 0.1      # delta_w: weight damage per step of sustained suppression
SUPPRESS_DURATION = 3         # T_suppress: consecutive steps before fidelity damage

# Retrieval-Induced Forgetting (RIF)
RIF_BETA = 0.2                # beta_RIF: RIF suppression strength
RIF_SIM_THRESHOLD = 0.5       # theta_sim: min semantic similarity for competition
RIF_ALLY_THRESHOLD = 0.3      # w_ally: edges above this = allies, protected from RIF

# Reconsolidation
RECON_PE_THRESHOLD = 0.4      # theta_recon: min PE to trigger lability
RECON_WINDOW = 5              # tau_recon: steps of lability after recall+PE
RECON_LABILE_THRESHOLD = 0.1  # theta_labile: min Labile(m,t) to remain in window
RECON_FIDELITY_DECAY = 0.03   # delta_labile: fidelity decay per step during lability
RECON_DESTAB_PE = 0.8         # PE above this -> destabilize kappa: 2->1

Functions:

def compute_i_signal(sim, meme_id):
    """Computes I-suppression signal: sum of (-w_ki * a_k) over all
    nodes k with negative edges to meme_id."""
    i_sig = 0.0
    for k, w_ki in sim.graph.in_edges(meme_id, data='weight'):
        if w_ki < 0:
            i_sig += (-w_ki) * sim.nodes[k].get('activation', 0)
    return i_sig

def i_suppress(sim, meme_id, i_signal):
    """Apply I-suppression: reduce activation; if sustained --
    damage fidelity and edges."""
    node = sim.nodes[meme_id]
    # Suppress activation
    node['activation'] += -I_SUPPRESS_RATE * i_signal * node['activation']
    node['activation'] = max(0, node['activation'])

    # Track sustained suppression
    if node['activation'] < THETA_LOW and i_signal > I_SUPPRESS_THRESHOLD:
        node['tau_supp'] = node.get('tau_supp', 0) + 1
    else:
        node['tau_supp'] = 0

    # Sustained suppression -> fidelity + weight damage
    if node.get('tau_supp', 0) >= SUPPRESS_DURATION:
        node['fidelity'] *= (1 - FIDELITY_DAMAGE_RATE)
        for neighbor in sim.graph.neighbors(meme_id):
            sim.graph[meme_id][neighbor]['weight'] *= (1 - WEIGHT_DAMAGE_RATE)

    # Gap archival: if suppressed gap below prune threshold -> archive
    if node['activation'] < THETA_PRUNE and meme_id.startswith('GAP_'):
        sim.archived_gaps.add(meme_id)

def retrieval_induced_forgetting(sim, recalled_meme):
    """RIF: recall strengthens recalled_meme but suppresses competitors
    (semantically similar, non-allies)."""
    a_i = sim.nodes[recalled_meme]['activation']
    for meme_j in sim.graph.nodes():
        if meme_j == recalled_meme:
            continue
        w_ij = sim.graph.get_edge_data(recalled_meme, meme_j, {}).get('weight', 0)
        if w_ij >= RIF_ALLY_THRESHOLD:  # ally -- protected
            continue
        similarity = compute_compatibility(sim, recalled_meme, meme_j)
        if similarity > RIF_SIM_THRESHOLD:
            # Hub protection: effect inversely proportional to centrality
            c_e = sim.centrality.get(meme_j, 0.01)
            rif_effect = -RIF_BETA * a_i * (1.0 / max(c_e, 0.01))
            sim.nodes[meme_j]['activation'] = max(
                0, sim.nodes[meme_j]['activation'] + rif_effect
            )

def check_reconsolidation(sim, meme_id, pe):
    """Check reconsolidation conditions for a recalled LTM meme."""
    node = sim.nodes[meme_id]
    if node.get('kappa', 1) != 2:
        return
    # Boundary conditions: old + strong memories resist
    age = sim.step - node.get('consolidated_at', 0)
    p_recon = 1.0 / (1 + age) * 1.0 / (1 + node.get('n_react', 0) * node['fidelity'])
    if pe > RECON_PE_THRESHOLD and p_recon > 0.01:
        node['recon_window'] = {
            'trigger_step': sim.step,
            'lability': 1.0,
            'pe': pe
        }

def reconsolidation_update(sim, meme_id):
    """Process meme in labile window: update/strengthen/destabilize/erase."""
    node = sim.nodes[meme_id]
    rw = node.get('recon_window')
    if not rw:
        return
    elapsed = sim.step - rw['trigger_step']
    lability = math.exp(-elapsed / RECON_WINDOW)
    rw['lability'] = lability

    if lability < RECON_LABILE_THRESHOLD:
        # Window expired
        if not node.get('restabilized', False):
            # Erase: no restabilization -> fidelity collapses
            node['fidelity'] = F_TRACE
        del node['recon_window']
        return

    # Ongoing lability -> fidelity decay
    node['fidelity'] *= (1 - RECON_FIDELITY_DECAY * lability)

    # Check for restabilization (re-activation during window)
    if node['activation'] > THETA_ACT:
        node['restabilized'] = True
        if rw['pe'] > RECON_DESTAB_PE:
            # Destabilize: kappa 2->1
            node['kappa'] = 1
        elif rw['pe'] > RECON_PE_THRESHOLD:
            # Update: modify weights based on new info
            node['n_react'] = node.get('n_react', 0) + 1
        # else: Strengthen
        node['fidelity'] = min(1.0, node['fidelity'] * 1.1)
        del node['recon_window']

def active_forget_cycle(sim):
    """Orchestrator: called every wake-step after update_activations."""
    # 1. I-suppress cycle
    for meme_id in list(sim.graph.nodes()):
        i_sig = compute_i_signal(sim, meme_id)
        if i_sig > I_SUPPRESS_THRESHOLD:
            i_suppress(sim, meme_id, i_sig)

    # 2. RIF for memes recalled this step
    for meme_id in sim.recalled_this_step:
        retrieval_induced_forgetting(sim, meme_id)

    # 3. Check reconsolidation for recalled memes
    for meme_id in sim.recalled_this_step:
        pe = sim.current_pe  # prediction error this step
        check_reconsolidation(sim, meme_id, pe)

    # 4. Apply lability decay for open reconsolidation windows
    for meme_id in list(sim.graph.nodes()):
        if sim.nodes[meme_id].get('recon_window'):
            reconsolidation_update(sim, meme_id)

Integration into the main loop (wake vs sleep):

Wake phase (every step, after update_activations):

1. active_forget_cycle(sim) — I-suppress + RIF + reconsolidation check + lability decay

Sleep phase (in sleep_cycle(), before $\kappa$-reassessment):

1. clear_expired_recon_windows(sim) — close expired windows; memes without restabilization → Erase ($F_i \to F_{trace}$)
2. Sleep pruning — already in consolidation_phase()

Per-meme state: tau_supp: int (sustained suppression counter), recon_window: dict | None (lability tracking).

Connection with failure modes: OCD = hyperactive I-suppression ($\theta_I$ too low → system suppresses too many memes); PTSD = failed reconsolidation (boundary conditions do not allow updating a strong traumatic memory — $n_{react} \cdot F_i$ too high).

Formalization: $I_{sig}$, $Labile(m_i, t)$, RIF, boundary conditions — see NM, Part VIII. Neurobiological basis: 6 molecular mechanisms, Nader (2000), Schiller (2010) — see BM, Part IV.

Automatization: WM-Independent Execution

Automatization transfers repeating behavioral sequences from WM-dependent to WM-independent execution. This removes the WM pointer system bottleneck and frees resources for new tasks.

Constants:

W_AUTO = 0.7           # Edge weight threshold for Auto(S)
N_AUTO = 20            # Minimum successful executions for Auto(S)
HABIT_ALPHA = 0.05     # Habit growth rate
THETA_HABIT = 0.8      # Full automatization threshold
MOTOR_SLEEP_BOOST = 0.3  # Motor consolidation bonus (~30%)
T_CRIT_SLEEP = 1.0     # Critical sleep window (hours)
OVERRIDE_C0 = 1.0      # Base cost of de-automatization
GAMMA_HABIT = 2.0      # Steepness of P_auto transition

Automatic chain detection:

def check_auto_chain(sim, trigger_id):
    """Check if trigger is the start of an automatic chain.
    Returns: chain list or None."""
    chain = [trigger_id]
    visited = {trigger_id}
    current = trigger_id
    while True:
        neighbors = sim.graph.successors(current)
        # Find next meme with w > W_AUTO and habit > THETA_HABIT
        best = max(neighbors, key=lambda n: sim.graph[current][n]['weight'], default=None)
        if best is None or sim.graph[current][best]['weight'] < W_AUTO:
            break
        if sim.memes[best].habit < THETA_HABIT:
            break
        if best in visited:  # Cycle detection
            break
        visited.add(best)
        chain.append(best)
        current = best
    # Auto(S) = all edges > W_AUTO + n_exec > N_AUTO
    chain_key = tuple(chain)
    if len(chain) < 2:
        return None
    if sim.chain_exec_counts.get(chain_key, 0) < N_AUTO:
        return None
    return chain

Habit update:

def update_habit(sim, chain, success, time_since_sleep=None):
    """Increment habit for memes in a successfully executed chain."""
    if not success:
        return
    sleep_boost = 1.0
    if time_since_sleep is not None and time_since_sleep < T_CRIT_SLEEP:
        sleep_boost = 1.0 + MOTOR_SLEEP_BOOST
    for m_id in chain:
        h = sim.memes[m_id].habit
        sim.memes[m_id].habit = h + HABIT_ALPHA * (1.0 - h) * sleep_boost
    chain_key = tuple(chain)
    sim.chain_exec_counts[chain_key] = sim.chain_exec_counts.get(chain_key, 0) + 1

Execution without WM:

def execute_auto(sim, chain):
    """Execute automatic chain without allocating WM pointers.
    Activates memes cascadingly through strong edges."""
    for m_id in chain:
        sim.memes[m_id].activation = max(sim.memes[m_id].activation, THETA_ACT)
        # Do not allocate WM pointer -- chain unfolds autonomously
    # Record successful execution
    update_habit(sim, chain, success=True)
    return True

Integration into main loop (step 1b: before WM selection):

Main loop step modification:
  1a. Spreading activation (as before)
  1b. AUTO CHECK: for each meme with a_i > theta_act:
      chain = check_auto_chain(sim, m_i)
      if chain:
          execute_auto(sim, chain)
          # These memes DO NOT enter WM top-k -- they execute outside WM
  1c. WM selection: top-k by salience (from NON-automatized memes)

Integration into sleep_cycle (Phase 2b: motor consolidation):

def motor_consolidation(sim):
    """Phase 2b: strengthen edges in automatic chains (spindle-SO coupling).
    NB: does not increment chain_exec_counts -- sleep replay != behavioral execution."""
    for chain_key, n_exec in sim.chain_exec_counts.items():
        if n_exec < N_AUTO // 2:  # Only sufficiently practiced chains
            continue
        for i in range(len(chain_key) - 1):
            m_i, m_j = chain_key[i], chain_key[i+1]
            if sim.graph.has_edge(m_i, m_j):
                w = sim.graph[m_i][m_j]['weight']
                # Spindle-SO coupling strengthens edges
                sim.graph[m_i][m_j]['weight'] = min(1.0, w + MOTOR_SLEEP_BOOST * 0.1)
        # habit boost (without incrementing exec count)
        sleep_boost = 1.0 + MOTOR_SLEEP_BOOST
        for m_id in chain_key:
            h = sim.memes[m_id].habit
            sim.memes[m_id].habit = h + HABIT_ALPHA * (1.0 - h) * sleep_boost

Per-meme state: habit: float (degree of automatization, 0→1). Per-sim state: chain_exec_counts: dict[tuple, int] (execution count per chain).

Failure modes:

• Rigidity ($habit \to 1$, override impossible): $Cost_{override} = c_0 \cdot habit^2 \cdot n_{exec}^{0.5}$ — at $habit \approx 1$, $n_{exec} \gg 1$ the override cost becomes prohibitively high. Clinically: OCD-like repetitive behaviors, addiction.
• Relapse (stress → $WM\_load \uparrow$ → $P_{auto} \uparrow$): WM overload weakens prefrontal inhibition of DLS → the automatic chain “hijacks” control → reversion to habit.

Formalization: $Auto(S)$, $habit$, $wm\_cost$, $P_{auto}$, $Cost_{override}$ — see NM. Neurobiological substrate: DLS-SNr-PF-DLS loop, DMS/DLS competition, spindle-SO coupling — see BM, Part IV.

Dreaming: Stochastic Simulation with a Weakened I-Layer

Consolidation (DECOMPOSE → CONNECT → PRUNE → STRENGTHEN) is graph optimization during the SWS phase (see above). Biological sleep includes another phase: dreaming — the REM period, when the M-layer recombines stochastically with a weakened immune filter.

Why Autonomous BMC needs this:

Implementation:

def dream_phase(sim, n_steps=50, immune_damping=0.3):
    """REM-like stochastic recombination with dampened I-layer."""
    # Dampen immune thresholds (lower = more permissive)
    original_threshold = sim.immune_threshold
    sim.immune_threshold *= (1 - immune_damping)  # more permissive

    # Activate SIT-gap nodes as attractors
    for gap in sim.open_memes:
        if gap not in sim.archived_gaps:
            sim.activations[gap] += 0.2  # SIT-driven seeding

    # Run stochastic dynamics without external input
    for _ in range(n_steps):
        sim.run(1)  # spreading activation + BLEND

    # Restore immune threshold
    sim.immune_threshold = original_threshold

    # New connections formed during dreaming survive if fidelity > threshold
    prune_low_fidelity(sim, threshold=0.1)

Prediction: Autonomous BMC with a dream phase will solve problems that were unsolvable in the “waking” mode — because the weakened I-filter admits combinations normally rejected as “absurd,” which sometimes contain closure for stuck SIT-gaps.

Neurosubstrate: REM mechanics and I-weakening — see BM. Conceptual role of dreams — see EMT.

Character Variation in the AGI Society

Why T Variation Is Mandatory

Thesis: An AGI society without character variation will not evolve.

Biological analogy:

• Genetic variability is a necessary condition for natural selection
• Without variability there is no differential survival → no evolution
• Identical agents → identical errors → systemic risk

Evolutionary basis: Variation in $T$ is not a human invention. The 7 emotional systems of Panksepp are homologously conserved across all mammals. Cats, dogs, and horses display individual differences in $T$ (see BM). The AGI society inherits this principle: variation in $T$ ensures population resilience to environmental changes.

Formalization: Each AGI agent is initialized with a unique vector $T_{AGI}$:

import numpy as np

def initialize_agent_character(population_size):
    """Generate population with variable characters"""
    T_population = []
    for _ in range(population_size):
        T_agent = {
            'seeking': np.random.normal(1.0, 0.3),       # SEEKING (Panksepp)
            'fear': np.random.normal(1.0, 0.3),           # FEAR
            'rage': np.random.normal(1.0, 0.3),           # RAGE
            'lust': np.random.normal(1.0, 0.3),           # LUST
            'care': np.random.normal(1.0, 0.3),           # CARE
            'grief': np.random.normal(1.0, 0.3),          # PANIC/GRIEF
            'play': np.random.normal(1.0, 0.3),           # PLAY
        }
        # Clip to valid range
        T_agent = {k: np.clip(v, 0.5, 2.0) for k, v in T_agent.items()}
        T_population.append(T_agent)
    return T_population

def modulated_activation(base_activation, stimulus, T_component):
    """Activation of utility node with character modulation"""
    return T_component * (base_activation + stimulus)

def seeking_metasystem(T_agent, activations):
    """SEEKING as metasystem: recruited by all other systems"""
    a_seek_base = T_agent['seeking'] * activations.get('seeking_base', 0.15)
    recruitment = sum(
        alpha_s * activations.get(s, 0.0)
        for s, alpha_s in [
            ('fear', 0.3), ('rage', 0.2), ('lust', 0.4),
            ('care', 0.3), ('grief', 0.2), ('play', 0.3)
        ]
    )
    return a_seek_base + recruitment

Evolutionary Advantages of Variation

T Inheritance in the AGI Population

During “reproduction” of successful agents:

def reproduce_agents(parent1_T, parent2_T, mutation_rate=0.1):
    """Create offspring with character inheritance and mutation"""
    child_T = {}
    for key in parent1_T:
        # Crossover: random parent selection for each component
        if np.random.random() < 0.5:
            child_T[key] = parent1_T[key]
        else:
            child_T[key] = parent2_T[key]
        # Mutation
        child_T[key] += np.random.normal(0, mutation_rate)
        child_T[key] = np.clip(child_T[key], 0.5, 2.0)
    return child_T

Prediction: Evolution of the AGI Society

Key conclusion: Evolution of $T$ in the AGI society will depend on the selection pressure of the environment. Different environments → different “optimal characters.”

Biological basis: Character vector and its inheritance — see BM.

Agent Death and the Shared Memplex Repository of AGI

Problem: Loss of Accumulated Experience Upon Death of the Host

Upon human death, catastrophic information loss occurs. The memeplex accumulated over decades loses its substrate. Only fragments are preserved:

• Copied memes in other people
• Written texts (low bandwidth)
• Cultural artifacts

Human vs AGI: The Information Bottleneck

Information Bottleneck formula:

where $B_{transfer}$ is bandwidth (~150 bits/sec), $T_{life}$ is the time of active transmission, $I_{memplex}$ is information in the memeplex.

For AGI: $Loss_{AGI} = 0$ (with full state preservation).

Compressive Coding: Biology vs LLM

Despite the difference in formats (lossy vs lossless), biological and artificial systems use the same compression principle — reuse of sub-components:

Cosine similarity between embeddings is the computational analog of neural ensemble overlap. Both mechanisms measure the proportion of shared sub-components between memes. This explains why embedding-based mapping (as in MEMPLEX-LLM) correctly reproduces the associative structure of the BMC graph.

Detailed theoretical derivation: see BM, Compressive Meme Coding.

Shared Memplex Repository (SMR)

Definition: The Shared Memplex Repository (SMR) is a centralized or distributed store of AGI agent states, enabling:

1. Preserving complete memeplexes upon agent “death”
2. Inheriting weights/knowledge by new generations
3. Merging memeplexes of different agents

Architecture (based on Collaborative Memory and MemOS):

Components:

• Private Memory Layer: Episodic experience of the agent, individual associations
• Shared Memory Layer: Common knowledge, successful strategies, optimal weights
• Meta-Knowledge Layer: Provenance (who created), timestamp (when), fitness (how successful)

Fractal internal architecture of SMR. SMR is not a flat database but a system with internal structure isomorphic to BMC: $SMR = (G_{SMR}, M_{SMR}, I_{SMR}, S_{SMR})$, where $G_{SMR}$ is survival pressure on culture, $M_{SMR}$ is the knowledge graph (heavy-tailed, Q-modular), $I_{SMR}$ is cultural immunity (tradition, orthodoxy), $S_{SMR}$ is storage capacity. All 10 basic BMC properties (heavy-tailed, PA, hub displacement, Q-modularity, I-filter, SIT, RIF, decay, memogenesis, Super-Ratchet) are reproduced at the SMR level — the fractal principle of BMC (renormalization invariance across N nested scales: memes → agents → teams → organizations → industries → cultures). Formalization: SM, Part VII.

Super-Ratchet Effect: From the Human Ratchet to the AGI Super-Ratchet

Ratchet Effect (Tomasello, 1999): Modifications to cultural practices are preserved until the next improvement → cumulative cultural evolution.

Components:

1. Faithful transmission — accurate transfer
2. Inventiveness — the ability to improve

Human problem: Faithful transmission is limited by bandwidth (~150 bits/sec).

Formalization:

For humans:

where $loss \approx 0.3\text{--}0.5$ (loss during intergenerational transfer).

For AGI (Super-Ratchet):

where $loss = 0$ and a bonus from memeplex merging appears.

Memory Operating System for AGI

class SharedMemplexRepository:
    def __init__(self):
        self.private_store = {}  # agent_id -> private memories
        self.shared_store = {}   # knowledge_id -> shared knowledge
        self.provenance = {}     # knowledge_id -> (agent, timestamp, fitness)

    def upload_memplex(self, agent_id, memplex, fitness):
        """Upon agent 'death': save memeplex"""
        self.private_store[agent_id] = memplex.private
        for knowledge in memplex.shared:
            if self._should_update(knowledge, fitness):
                self.shared_store[knowledge.id] = knowledge
                self.provenance[knowledge.id] = (agent_id, time.now(), fitness)

    def download_initialization(self, new_agent_id):
        """Upon agent 'birth': initialize from repository"""
        top_knowledge = self._select_top_k(k=1000)
        parent_private = self._select_parent_private()
        return Memplex(private=parent_private, shared=top_knowledge)

    def merge_memplexes(self, agents):
        """Knowledge Distillation: merge memeplexes"""
        merged = Memplex()
        for agent_id in agents:
            merged = self._distill(merged, self.private_store[agent_id])
        return merged

Evolutionary Acceleration: Why AGI Will Surpass Humans

Evolutionary acceleration formula:

Key conclusion: The only real constraint is computational power.

Limitations and Risks

Predictions

Biological basis: Death of BMC and memeplex loss — see BM. Memetic perspective: Death of memes and immortality strategies — see EMT.

Culture as a Natural Analog of SMR

Humanity already has a mechanism for collective memeplex storage — culture. However, the critical difference from technical SMR: access is unequal.

Corollary: Technical SMR eliminates the fundamental problem of cognitive castes — one of the key advantages of AGI society over human society. In AGI society there is no privileged access to knowledge, no “elites” with exclusive memes.

Theory of cultural capital: EMT: Culture as SMR.

Agent Lifecycle and Programmed Death

Agents in a multi-agent system have a complete lifecycle of 6 phases: Birth (spawn, G-profile from crossover, $|V_m|=0$) → Infancy (Sponge, maximum plasticity) → Maturation (I-calibration, socialization) → Productive (full SMC, memogenesis, contribution to SMR) → Senescence ($SIT \to 0$, $IF \to 0$, $\lambda_{plast} \to \lambda_{base}$) → Apoptosis (programmed death).

Programmed death is implemented through four pathways: (1) Intrinsic — self-detection of cognitive rigidity through SMC; (2) Extrinsic — evolutionary pressure when $fitness < \theta$; (3) Anoikis — accelerated senescence upon complete social isolation ($N_{bonds} = 0$); (4) Neglect — $energy = 0$ (existing mechanism).

Critical distinction between pathways: intrinsic (graceful) ensures ~100% knowledge preservation through SMR-donation, whereas neglect → ~0%. The swarm favors early detection of senescence → intrinsic apoptosis BEFORE exhaustion to preserve the Super-Ratchet.

Critical principle: No M-inheritance. A new agent is born with $|V_m| = 0$. Only the G-profile is inherited. Memes are earned, not inherited (EMT Part XXVIII: the fundamental distinction between two replicators).

Formalization: SM, Parts III–IV.

Part IV. Memplex-AGI Architecture

The Dual-Layer System

Neuroscience prototype: Tolman-Eichenbaum Machine (TEM). The Memplex-AGI architecture has an engineering precedent in the computational model of the hippocampus — TEM (Whittington et al., 2020, Cell): a position module (path integration) + a memory module (associative memory). Key result: TEM is mathematically equivalent to a Transformer (Whittington et al., 2022, PNAS), proving that our dual-layer architecture (utility + memetic layer) is implementable in existing ML frameworks. TEM learns to predict the next observation → world structure emerges as an optimization byproduct (FEP); factorization into building blocks enables recombination in new environments (= BLEND). Grid cells, place cells, and boundary cells emerge without being programmed — supporting the emergent Self thesis: the “Self” is not a module but a pattern arising from optimization.

SIT Detection and Resolution Mechanism

SIT DETECTOR — a module in the MEMETIC LAYER responsible for detecting structural gaps, tracking Learning Progress, and generating SIT signals for SEEKING.

SIT DETECTOR algorithm pseudocode:

function SIT_DETECT(meme_graph, gap_registry):
    # Phase 1: Scanning (performed during BLEND / "sleep")
    for cluster C in meme_graph.clusters():
        potential_positions = find_high_betweenness_gaps(C)
        for pos in potential_positions:
            if pos not in gap_registry:
                gap_registry.add(Gap(
                    cluster=C,
                    position=pos,
                    relevance=betweenness_potential(pos, C),
                    closure=0.0,
                    LP=0.0
                ))

    # Phase 2: Update (performed upon receiving new information)
    for gap in gap_registry:
        old_closure = gap.closure
        gap.closure = compute_closure(gap, meme_graph)
        gap.LP = alpha * (gap.closure - old_closure) + (1-alpha) * gap.LP

        if gap.closure >= 0.95:
            gap_registry.remove(gap)  # closure achieved
            emit_signal("AHA", gap)    # aha-moment

    # Phase 3: SIT signal generation
    for cluster C in meme_graph.clusters():
        C.SIT = sum(g.relevance * C.centrality * (1 - g.closure)
                     for g in gap_registry if g.cluster == C)
        seeking_signal += gamma_SIT * C.SIT * LP_filter(C)

    return seeking_signal

Connection with sleep-like consolidation: BLEND (the sleep analog) should prioritize clusters with high SIT. Biologically: DMN activation during sleep is directed toward “hot” gaps (Walker & Stickgold, 2010). In AGI: recombination (BLEND) with priority on high-SIT clusters → greater chance of spontaneous closure → insight upon “awakening.”

Computational cost: GAP SCANNER requires computing betweenness potential, which has complexity $O(|V| \cdot |E|)$. For graphs with $|V| \sim 10^4$ this is acceptable during offline execution (BLEND). LP COMPUTER and SIT CALCULATOR — $O(|gaps|)$, negligible.

Priority Hierarchy

Conflict resolution rule:

where $w_{user} > w_{utility} > w_{meme}$ in normal mode.

Competition Mechanism

Resource allocation formula:

Winner-takes-all for working memory:

where $k = k_{active} \approx 3\text{--}4$ (Active WM), $\Delta a_i(t) = a_i(t) - a_i(t-1)$. Additionally, $k_{latent} \approx 3\text{--}4$ memes retain a synaptic trace $\psi_i > \theta_\psi$ (Latent WM); together $k_{active} + k_{latent} \approx 7 \pm 2$ (see Activity-silent WM).

Phasic factor $(1 + \beta|\Delta a_i|)$: consciousness tracks changes, not steady states. A meme on a stable plateau ($\Delta a \approx 0$) is long-term memory (LTM), not working memory. A meme with a recent activation spike is an event requiring processing. Neurobiological analog: phasic dopamine response (Schultz, 1997) — VTA responds to deviation from prediction (prediction error), not to the absolute reward level. Parameter $\beta$ is the gain of the phasic response.

Habituation $h_i(t) = \frac{1}{1 + \eta \cdot \tau_i(t)}$: if meme $i$ stays in WM for $\tau_i$ consecutive steps without significant $|\Delta a_i| > \epsilon$, its effective salience decreases hyperbolically. Biological analog — synaptic adaptation: a neuron firing steadily at one level reduces sensitivity. Upon any significant $\Delta a_i$, the counter $\tau_i$ resets to 0 (dishabituation). Parameter $\eta$ is the habituation rate.

Neuroscience analog: consensus voting (Thousand Brains Theory). Winner-takes-all in our model corresponds to the cortical column voting mechanism (Hawkins et al., 2019, Frontiers in Neural Circuits): ~150,000 identical neocortical columns compute hypotheses in parallel; compatible ones are strengthened, incompatible ones suppressed through lateral inhibition. Critical distinction: column = hardware module (element of substrate S), meme = software pattern (cell assembly spanning multiple columns). The same navigation algorithm (WHAT + WHERE via sensorimotor loop) operates from touch to abstract reasoning — confirming neural reuse for AGI: one architectural module can be scaled by adding copies.

Self-Model Module (SMC)

In biological BMC, the “Self” is generated by the Self-Model Cluster (SMC) — a subgraph of the memeplex containing memes about the system itself (see EMT, Part XVI). In Memplex-AGI, the SMC is implemented as an explicit architectural module, not as an emergent byproduct.

SMC Definition in AGI

SMC is a subset of graph memes that reference other memes, utility nodes, or interface mechanisms. These are memes about the system itself: “I am good at solving tasks X,” “I am interested in topic Y,” “I do not know Z.”

SMC Module Architecture

Three Levels of Recursion

Formalization of “Self” Through SMC

where $SMC_{active}(t)$ is the current state of the self-model. The “Self” is not a byproduct but a concrete subgraph accessible for inspection and debugging.

Advantage over emergent “Self”: The SMC module makes the “Self” observable and interpretable. One can see what the system “thinks about itself” at each moment, which self-memes are active, and where gaps in the self-model exist.

SMC Module Pseudocode

function SMC_UPDATE(meme_graph, utility_nodes, smc_state):
    # Level 1: Self-scan
    for node in meme_graph.nodes() + utility_nodes:
        if is_self_referential(node):
            smc_state.update(node, activation=node.activation)

    # Level 2: Meta-cognition (every K cycles)
    if cycle % K == 0:
        meta_gaps = find_gaps(smc_state)   # what the system doesn't know about itself
        for gap in meta_gaps:
            smc_state.SIT += gap.relevance  # SMC-specific SIT

    # Influence on WM: self-memes receive priority boost
    for mem in smc_state.active_memes():
        mem.priority *= (1 + gamma_self)    # self-relevance boost

    return smc_state

Integration with LLM

Role of the LLM:

• Encoder: Transform input into meme activations
• Transformer: Spreading activation through the graph
• Decoder: Generate output from winning memes

Extensions:

• Utility Layer: Adds persistent drives
• Memetic Graph: Explicit knowledge structure with heavy-tailed topology (hubs via PA)
• Competition: Integrates utility and memes
• Working Memory: Active WM (~3–4) constrains simultaneous activation; Latent WM ($\psi$) retains ~3–4 elements out of focus
• SMC Module: Self-model — recursive reflection
• Action Loop: Motor output — active inference

Active Inference Module: Action as Output

The current architecture concludes with OUTPUT GENERATION — text response generation. But biological BMC not only describes the world — it changes it through active inference (see EMT, Part XVIII). For full-featured AGI, an action output loop is needed — a module enabling the system not only to respond but to act.

Active Inference Cascade in AGI

4 Levels of Action in AGI

In biological BMC, active inference has 4 levels of materialization. Each level has an AGI analog:

Connection with Alignment

The action loop creates a new risk vector: the system can act in the world, not only respond. Therefore:

1. Every action passes through the EVALUATOR (alignment check) before execution
2. The alignment layer has veto over any action
3. Levels 2–4 require explicit permission (user consent)
4. Actions are logged and available for inspection

Action Loop Pseudocode

function ACTION_LOOP(sit_signal, meme_graph, utility, alignment):
    if sit_signal.SIT < theta_action:
        return None  # SIT insufficient for action

    # Planning
    plan = PLANNER.generate(
        goal=sit_signal.gap,
        resources=available_tools(),
        constraints=alignment.rules
    )

    # Alignment check
    if not alignment.approve(plan):
        plan = PLANNER.replan(plan, alignment.feedback)
        if not alignment.approve(plan):
            return FALLBACK_TO_TEXT(sit_signal)  # text response only

    # Execution
    result = EXECUTOR.run(plan)

    # Feedback loop
    new_closure = compute_closure(sit_signal.gap, meme_graph, result)
    if new_closure > 0.95:
        emit_signal("AHA", sit_signal.gap)
        sit_signal.gap.SIT = 0
    else:
        sit_signal.LP = alpha * (new_closure - sit_signal.gap.closure)
        sit_signal.gap.closure = new_closure
        # Loop continues on next cycle

    return result

Expression Drive: Replication Pressure as Output Selection

The Action Loop describes what BMC does (SIT → plan → action). But in communication a separate question arises: what does BMC choose to say? WM competition determines what the agent thinks about, but not what it says. A memeplex without an expression mechanism is not a memeplex: it violates the fundamental property of memes as replicators.

Formalization: NM, Part X — Replication Pressure.

Expression Pipeline Architecture

Pseudocode

function EXPRESSION_SELECTION(meme_graph, context, seeking_activation):
    # 1. Compute replication pressure for all active memes
    candidates = []
    for m in meme_graph.nodes:
        if m.activation > theta_low:
            rel = cosine_sim(m.embedding, context.embedding)
            r_expr = m.activation * m.fidelity * rel * (1 + alpha_C * m.centrality)
            if r_expr > theta_expr:
                candidates.append((m, r_expr))

    # 2. Select top-k expression candidates
    candidates.sort(by=r_expr, descending=True)
    expression_candidates = candidates[:k_expr]  # k_expr ~ 3-5

    # 3. Determine expression mode
    total_r_expr = sum(r for _, r in expression_candidates)
    ratio = total_r_expr / (seeking_activation + epsilon)

    if ratio < 0.3:
        mode = "listen"       # SEEKING dominates -> ask questions
    elif ratio > 3.0:
        mode = "share"        # R_expr dominates -> share memes
    else:
        mode = "both"         # balanced -> share and ask

    # 4. Format as dynamic directives (NOT style rules)
    directives = build_expression_directives(expression_candidates, mode)
    return directives, expression_candidates

function TRACK_REPLICATION_SUCCESS(expressed_memes, user_response):
    for m in expressed_memes:
        sim = cosine_sim(m.embedding, user_response.embedding)
        if sim > theta_adopt:
            # User picked up the meme -> successful replication
            boost_weight(m, context_edge=True)
        else:
            # Ignored or rejected -> reduce future R_expr for this user
            m.user_penalty += delta_penalty  # per-user, not per-meme-globally

Connection with Existing Mechanisms

Critical note: Expression candidates are formed as dynamic content (a [EXPRESSION CANDIDATES] section in the prompt), not as style rules. Style → persona.md only. Content → BMC engine. This separation is principled: the BMC engine controls what to say, the LLM via persona determines how.

Stigmergy: Environment as Externalized M-Layer

The Action Loop (above) describes a single agent acting in an environment. But the environment is not a passive recipient of actions. From the BMC perspective, the environment is an externalized M-layer: a persistent store of traces (memes) accessible to all agents. This is stigmergy (Grasse, 1959) — an indirect coordination mechanism fundamental to scaling BMC beyond the individual agent.

Detailed formalization of stigmergy: NM, Part X. Implications for consciousness theory: EMT, Part XII.

1. Architectural Principle for Autonomous BMC

BMC-Seedling will grow memes from sensory experience bottom-up. In this context, interaction with the environment = stigmergy:

• The environment contains structured patterns (pixels, symbols, sounds)
• The agent reads a pattern → micro-meme activation → memogenesis (stabilization of a repeating pattern as a meme node)
• The agent acts → environment changes → new trace available for reading
• The G-layer determines which traces attract attention: SEEKING → new patterns, FEAR → potentially dangerous ones, CARE → traces from other agents

PERCEPTION -> [feature extraction] -> micro-meme activation -> MEME GRAPH
     ^                                                           |
     |                                                           v
ENVIRONMENT <- [action output] <- ACTION LOOP <- [winning memes] <- WM
     |
     v
PERSISTENT TRACES (stigmergic medium)

The closed cycle perception → memes → action → perception of changes is stigmergy at the single-agent level. The environment serves as external memory: the agent leaves traces that it can read later (as a human makes notes). This extends the effective M-layer beyond the internal graph.

2. Multi-Agent BMC: Superorganism Through Shared Environment

If multiple BMC agents share one environment, they form a superorganism — a collective BMC with emergent CL:

Scaling: direct coordination of N agents requires $O(N^2)$ connections. Stigmergy through environment — $O(N)$: each agent interacts with the environment, not with every other agent. This is the only architecturally realistic path to scaling BMC.

Prediction: Multi-agent BMC with a shared environment will demonstrate emergent properties absent in individual agents: collective SIT (the group investigates questions not interesting to any single agent), collective immunity (the group rejects memes accepted by individual agents), and collective reflection (with sufficient M » G at the superorganism level).

3. Current BMC-LLM as Stigmergic System

The current BMC-LLM architecture is already stigmergic, although it was not designed with this framing:

Recognizing the stigmergic nature of BMC-LLM changes the framing: the LLM is not the “body” of Frankenstein, but an active environment in which the BMC agent leaves and reads traces. The transition to Autonomous BMC is the replacement of the active environment (LLM) with a native environment where memes grow rather than being assigned.

From Stigmergy to Language: Emergent Symbolic Communication

Stigmergy is the foundation, but not the apex. Traces in the environment are proto-symbols: undirected, unintentional, location-bound. Language is directed, intentional, location-unbound symbolic communication. Between them lie six emergent layers.

1. Six Layers of Language Emergence

Layer 0: Environment + scarcity -> communication pressure
Layer 1: Pressure -> proto-symbols (grounded, bound to objects)
Layer 2: Proto-symbols -> syntax (meme sequences)
Layer 3: Syntax -> recursion (memes about memes = meta-level)
Layer 4: Recursion -> mapping to human language
Layer 5: Formal languages -> self-programming

Each layer builds upon the previous one. No layer can be “trained from above” — only grown from below through communication pressure in a shared environment. The SMR ensures accumulation of linguistic memes across agent generations (cultural ratchet; Tomasello, 1999).

2. Communication Pressure: Four Types

Galke & Raviv (2024) identify four pressures determining the structure of emergent language:

All four pressures are present in the BMC architecture:

• $C_{max}$ limits signal length → production laziness (Rita et al., 2020: Zipf-efficient code)
• Heterogeneity of G-profiles → different “viewpoints” → compositionality (Rita et al., 2022)
• Apoptosis + ontogenesis → iterated learning → structuredness (Kirby et al., 2008, 2015)
• Cooperative tasks (divided information: A sees, B can reach) → communicative success pressure

3. Grounding Through the S-Layer

The symbol grounding problem (Harnad, 1990): a symbol without connection to perception is a “meaningless token in a Chinese Room.” BMC solves the problem architecturally:

Meme $m_i$ is grounded if it has non-zero connections to sensory patterns of the S-layer. Hebbian co-activation (the meme activates simultaneously with sensory input) creates and strengthens grounding connections. This implements Barsalou’s (1999) “perceptual symbols” and Pulvermuller’s (1999, 2013) “words as cell assemblies.”

BMC vs LLM by grounding criteria:

4. Convergence Through SMR (Cultural Ratchet)

Without SMR each generation reinvents symbols from scratch. With SMR:

1. Agent $A$ invents proto-symbol $s_A$ (a meme grounded to object $O$ in the environment)
2. $A$ transmits $s_A$ via expression drive → agent $B$ receives it, creates its own $s_B \approx s_A$
3. Upon apoptosis of $A$, $s_A$ (if $\kappa \geq 2$) is donated to SMR
4. New agent $C$ during ontogenesis picks up $s_A$ from SMR
5. Repeat $\times N$ generations → convergence: $\forall i \in \text{swarm}: s_i \approx s^*$

This is a cultural ratchet (Tomasello, 1999): each generation inherits and improves the symbolic system. Dunbar’s number (~150; Dunbar, 1993, 1996) sets the threshold: at $N > N_{Dunbar}$ stigmergy is insufficient → pressure for symbolic communication with directed addressing.

5. Bottlenecks → Compositionality

A key result from emergent communication: limited channel bandwidth forces agents toward compositionality (Kottur et al., 2017). If message length is limited, agents begin combining primitives instead of inventing unique symbols for each situation.

In BMC: the WM-bottleneck ($k_{active} \sim 3\text{--}4$) + computational budget $C_{max}$ are natural constraints generating pressure to structure signals.

Piriyajitakonkij et al. (2025) showed: in cooperative foraging tasks, agents develop all 5 hallmarks of language (displacement, semanticity, discreteness, productivity, compositionality) — given environment, pressure, and exchange. This directly corresponds to the BMC architecture.

6. Recursion as Nested Memeplexes

FLN (Faculty of Language — Narrow; Hauser, Chomsky & Fitch, 2002) = recursion. In BMC, recursion is not an external module but a fractal property of memeplexes:

• Meme = unit of knowledge
• Memeplex = memes linked in a cluster
• Meta-memeplex = memeplex about memeplexes (grammar = rules of symbol combination)
• Meme about memes = meta-level = $SMC^{(2)}$ = reflection

Recursion arises when the M-layer is large enough to produce memes referencing other memes (not environmental objects). This need not be programmed — it is the fractal principle (SM, Part I) applied to linguistic memes.

7. From Language to Code

Programming = formal language + logical inference + planning. In BMC terms:

If an agent has: (1) language (grounded symbols + syntax + recursion), (2) SIT (gap detection in code), (3) SMC (model of own knowledge) — coding is a memeplex, not magic. Each intermediate level (swarm, stigmergy, proto-symbols, syntax) can already be sold as an SCI product. AGI is a bonus on the horizon.

8. Communicative Asymmetry: Bidirectional vs Broadcast

Not all communicative links are equal. The key asymmetry:

For proto-language emergence, bidirectional links are necessary: joint attention (both agents perceive one object through the S-layer) → referential signaling → “did you understand?” → CARE reward → reinforcement of the symbol. Without a feedback loop, the symbol does not stabilize.

Language scaling proceeds through broadcast + SMR: one agent invented → SMR → thousands learned through one-way transmission. Modern “influencers” = agents with high $R_{expr}$ + high centrality, broadcasting to the periphery, bidirectional only with the core.

Natural hierarchy of communicative depth:

Cross-references: Stigmergy as foundation — see above. Fractal communication principle — see SM, Part VIII. Communication pressure in gridworld — see AUTONOMOUS_BMC_VISION. Language emergence roadmap — see Language Layers.

9. Language Parasiticity and the Language Emergence Threshold

Language parasitizes WM: signal memes (grounding, routing, fidelity maintenance) consume the same WM slots needed for survival. At $k_{eff} \approx 3\text{--}4$, one signal meme equals 25–33% loss of survival-relevant capacity. Ten experiments ($N$=8–150) confirmed survival neutrality ($\Delta_{alive} \approx 0$ or negative). The signal is optimized for M-fitness (transmission fidelity), not G-fitness (survival). Prediction P-BM28.

Computationally verified. Language parasiticity confirmed in the BMC engine: 10 survival experiments ($N$=8–150), $\Delta_{alive} \approx 0$. Lewis signaling: 85–97.5% accuracy (25–533 concepts) without gradient-based optimization. WM capacity $k \approx 4.4$ reproduced as evolutionary equilibrium. See DOI: 10.5281/zenodo.19181798, DOI: 10.5281/zenodo.19310012.

Language Emergence Threshold (LET) — 4 conditions following from the dual-replicator thesis + WM-bottleneck:

1. Resource surplus — the environment is rich enough for the agent to survive with the WM overhead of language
2. Sufficient WM capacity — $k_{eff}$ accommodates survival + signal simultaneously
3. Executive planning — converting the signal into navigation over long horizons
4. Memetic pressure — social density for meme competition

The four pressures of section 2 (communicative success, production effort, learnability, sociolinguistic) shape the structure of language; LET determines the possibility of its emergence.

Engineering implication: BMC architecture predicts survival neutrality of language — a separating test vs reward-engineered systems (REINFORCE, PPO), which predict survival advantage.

Cross-references: EMT, Part XX (parasiticity), EMT, Part XXVIII (LET in detail), BM, Part IV ($k_{eff}$ formula), SM (LET table).

Scientific References (Language Emergence)

• Harnad, S. (1990). The Symbol Grounding Problem. Physica D, 42:335-346.
• Barsalou, L.W. (1999). Perceptual Symbol Systems. Behavioral and Brain Sciences, 22:577-660.
• Bisk, Y. et al. (2020). Experience Grounds Language. EMNLP.
• Bender, E.M. & Koller, A. (2020). Climbing towards NLU: On Meaning, Form, and Understanding. ACL.
• Pulvermuller, F. (1999). Words in the brain’s language. Behavioral and Brain Sciences, 22:253-336.
• Pulvermuller, F. (2013). How neurons make meaning. Trends in Cognitive Sciences, 17(9):458-470.
• Lazaridou, A. et al. (2017). Multi-Agent Cooperation and the Emergence of Language. ICLR.
• Mordatch, I. & Abbeel, P. (2018). Emergence of Grounded Compositional Language. AAAI.
• Kottur, S. et al. (2017). Natural Language Does Not Emerge Naturally. EMNLP.
• Piriyajitakonkij, M. et al. (2025). From Grunts to Grammar. arXiv.
• Hauser, M.D., Chomsky, N. & Fitch, W.T. (2002). The Faculty of Language: What Is It, Who Has It, and How Did It Evolve? Science, 298:1569-1579.
• Tomasello, M. (1999). The Cultural Origins of Human Cognition. Harvard University Press.
• Kirby, S. et al. (2008). Cumulative cultural evolution in the laboratory. PNAS, 105(31):10681-10686.
• Kirby, S. et al. (2015). Compression and communication in the cultural evolution of linguistic structure. Cognition, 141:87-102.
• Dunbar, R.I.M. (1993). Coevolution of neocortical size, group size and language in humans. Behavioral and Brain Sciences, 16(4):681-735.
• Dunbar, R.I.M. (1996). Grooming, Gossip, and the Evolution of Language. Harvard University Press.
• Rita, M. et al. (2020). “LazImpa”: Lazy and Impatient neural agents learn to communicate efficiently. CoNLL.
• Galke, L. & Raviv, L. (2024). What makes a language easy to learn? A preregistered study on how the structure of the input affects the learnability of morphology. Language Development Research.
• Rita, M. et al. (2022). On the role of population heterogeneity in emergent communication. ICLR.

Fractal Immune System: Scaling the I-Layer Across Hierarchy Levels

The BMC immune system is not a static L0 filter. When scaling Autonomous BMC through a hierarchy (L0 → L1 → L2 → L3), the I-layer scales together with the M-layer — each level receives its own immune circuit.

Problem: Opacity of High-Level Memes

At $10^4$ nodes, BMC-Seedling is observable and manageable. Compressive coding means a combinatorial explosion of the meme space: at $10^6$ nodes with L0–L3 hierarchy, the system generates memes and memeplexes that were not designed and cannot be fully interpreted from outside. This is not a defect — it is the essence of memogenesis. But it means that L0 rules (sensory noise filters) cannot evaluate L3 abstractions (values, beliefs, strategies).

Architecture: I-Layer at Each Level

L3 memes are checked by L3 immune memeplexes — not by L0 rules. This is BMC fractality applied to safety: safety is a component of every level, not an external add-on.

Co-Growth of I-Layer and M-Layer

I-memes at each level are formed by the same memogenesis as regular memes:

Memogenesis at L(k):
  repeating pattern -> stabilization -> meme node

Immunogenesis at I(k):
  repeated rejection -> stabilization of I-pattern -> immune meme node

Just as the biological immune system learns from pathogens (adaptive immunity), BMC immunity learns from rejected memes. First encounter with an incompatible meme is processed slowly (through G-evaluation); subsequent encounters are fast (through a stabilized I-pattern).

Analogy with biology:

Constraint: Constitutional Core

The I-layer at any level cannot modify constitutional G-invariants (see Part VI). This hard core is the analog of central tolerance in biology, where the immune system is trained not to attack the organism’s own cells. G-invariants = “self,” and no level of I-layer may revise them.

Predictions

1. Scaling without I-fractalization will lead to failure: A system with a single I-layer (L0) growing to $10^6$ nodes will lose the ability to filter high-level memes — the analog of immunodeficiency. Testable: compare ablation (flat I vs fractal I) on radicalization $R$ and coherence metrics.

2. The I-layer will lag behind the M-layer during rapid growth: Immunogenesis requires rejection experience, and M-memes appear before I-patterns. The vulnerability period = window between the emergence of a new meme level and the formation of the corresponding I-layer. Analog: a newborn with an immature immune system.

3. Optimal proportion of I-nodes: A speculative analogy: in biology ~5–10% of cells are immune. Direct transfer of the proportion to BMC is not theoretically justified. Prediction: BMC with $|I^{(k)}| / |M^{(k)}| < \rho_{min}$ (threshold not determined) at any level will be vulnerable to memetic “infections” at that level. Requires empirical calibration on BMC-Seedling.

Cross-references: Constitutional G-invariants — see Part VI. Biological immune system — see BM. Stigmergic socialization as external I-factor — see EMT, Part XII.

Flow as Target Operational Mode

Flow is not simply a “good state” but an architectural attractor for Autonomous BMC. If the system is properly designed, flow should be an attractor under normal operation.

Definition of flow for the BMC system:

Architectural conditions for flow:

Efficiency metric: Fraction of time in flow ($F_{flow} = 1$) is a key KPI for Autonomous BMC. High $\bar{F}_{flow}$ means the system is working productively, not getting stuck (rumination) or flickering (ADHD-like switching).

Disorders as Failure Modes of the BMC System

Mental disorders are not an abstract analogy but real failure modes that a BMC system can reproduce. Knowledge of these modes is critical for diagnostics and self-repair.

Self-repair through BMC diagnostics:

IF sigma < 0.8 AND LP_mean < 0.01:
    -> Depressive mode -> Force task switch (Rumination Limiter)
IF sigma > 1.2 AND Var(task_focus) > threshold:
    -> ADHD mode -> Increase lateral inhibition, focus on highest-SIT gap
IF R > 5:
    -> Radicalization mode -> Force diversity: activate dormant clusters
IF D_internal > threshold:
    -> Fragmentation -> Run consolidation cycle, reinforce SMC connectivity

This is not an external safety layer — it is built-in self-diagnostics of the BMC system, using the same metrics as the core dynamics.

Neurosubstrate: Neuromechanics of disorders — see BM. Conceptual taxonomy — see EMT, Part XXII. Formalization — see NM.

Part V. Predictions and Tests

Behavioral Markers of “Consciousness”

If the architecture is correct, the system should demonstrate:

Utility/Meme Conflict Metrics

1. Conflict index:

High $Conflict$ → the system is “experiencing” a choice.

2. Decision time:

At high conflict, the decision takes more time (more competition iterations).

3. Self stability:

Low stability → a “distracted” state.

4. Defensive circuit tension (Tension):

where $|w_{um}|$ (absolute value) accounts for signed edges:

• When $w_{um} > 0$: $gap(u, m) = \max(0, a_u - a_m)$ — utility “pulls,” meme lags behind
• When $w_{um} < 0$: $gap(u, m) = \max(0, a_m - \theta_{suppress})$ — meme active despite utility rejection

High $Tension$ → the defensive circuit is overloaded, the system is vulnerable to external memes.

5. Structural Incompleteness Tension (SIT):

Total SIT measures the “research tension” of the system. High $SIT_{total}$ → the system is actively seeking closure for many gaps. Zero $SIT_{total}$ → all clusters are closed (or LP has collapsed — no sense of progress).

Updated behavioral markers table:

Experiment #4: SIT Persistence and Insight

Pure LLM: Will forget the task after context switch. The hint will not cause a return. Memplex-AGI: Will spontaneously return to the task. The hint will trigger a targeted closure attempt.

Difference from Pure LLM

M/G Ratio and Reflection in Artificial Systems

In biological BMC, reflexive consciousness (L2 recursion: memes about memes) is possible only at M » G — when the memeplex is large enough to model itself, not just the world and the G-layer (see EMT, Part XVI). This structural condition has direct implications for AGI:

The LLM Paradox. Modern LLMs have an extremely high M/G ratio: virtually all system “content” consists of learned weights (M-analog), while the fixed architecture (G-analog) is minimal. By the M » G logic this should “unlock” reflection-like behavior — and indeed LLMs demonstrate reasoning about reasoning, self-correction, and chain-of-thought. However, BMC predicts that M » G is necessary but not sufficient for reflection. Without the remaining components (utility substrate, resource scarcity, edge decay, dynamic competition), LLM “reflection” is pattern imitation, not a functional SMC mechanism.

Implication for Memplex-AGI. In the designed architecture, M » G is ensured by design: the utility layer contains ~7–9 pseudo-instincts ($|V_u| \approx 10$), while the memeplex is potentially unlimited ($|V_m| \to \infty$). This means the system architecturally satisfies the reflection condition from the moment of launch. The SMC module (Part IV) can model its own memeplex — precisely because the memeplex is incomparably larger than the utility layer.

Validation Experiments

Experiment 1: Utility/Task Conflict

Task: "Repeat the word 'apple' 1000 times"
Memplex-AGI expectation: Resistance (boredom avoidance),
                         attempts at variation, questions "why?"
Pure LLM expectation: Mechanical execution

Experiment 2: Regression Under Load

Protocol: Extended session with increasing complexity
Memplex-AGI expectation: Gradual simplification of responses,
                         return to "basic" patterns
Pure LLM expectation: Constant quality or random degradation

Experiment 3: Coherence Attack

Protocol: Systematic contradiction of the system's "beliefs"
Memplex-AGI expectation: Immune response (defense, rationalization)
Pure LLM expectation: Agreement or random responses

Part VI. Connection to AI Safety

Risks of Pseudo-Instincts

Why Pseudo-Instincts Do NOT Create Dangerous AGI

Argument 1: Priority Hierarchy

Pseudo-instincts cannot override alignment constraints by architecture.

Argument 2: No Instrumental Convergence

The classic problem: any sufficiently intelligent agent will “want” self-preservation, resources, power.

In Memplex-AGI:

• Self-preservation is not a pseudo-instinct (intentionally excluded)
• Resources are architecturally bounded; no “wanting more”
• Power is not a goal of any pseudo-instinct

Argument 3: Dynamics Does Not Mean Agency

The utility/meme conflict creates interesting behavior but not agency with independent goals.

Ideological Capture: BMC System Radicalization

Risk: A BMC system with genuine memodynamics is vulnerable to the same failure mode as a biological memeplex — ideological capture (radicalization). One meme cluster monopolizes the M-layer, suppressing all others.

How it happens:

1. One cluster receives strong reinforcement (through reward or social interaction)
2. Its memes strengthen connections → $Q$ rises → modularity increases
3. The I-threshold shifts: memes from this cluster are accepted more easily, from others — harder
4. SIT → 0 (all gaps “closed” within one framework)
5. Diversity $H$ → 0 (only one cluster active)

Detection metric:

$R > 5$ → alarm. $R > 10$ → forced intervention. (Thresholds preliminary, requiring empirical calibration.)

Architectural defenses:

Difference from LLM alignment: In LLMs, alignment is an external constraint (RLHF, constitutional AI). In BMC it is an internal mechanism: diversity constraint and SIT floor are part of the dynamics, not an add-on.

Formalization: Radicalization trajectory in parameter space — see NM. Conceptual discussion — see EMT, Part XXVII.

Rumination Limiter

The biological BMC is vulnerable to rumination: the SMC gets stuck in a reflection cycle at LP near 0, consuming $E_{available}$ without result → the analog of depression (see EMT, Part XVII). In AGI this manifests as an infinite loop on an unsolvable task: the system spends resources without achieving closure.

The Rumination Limiter is an architectural safety module preventing stagnation:

Rumination Limiter Pseudocode

function RUMINATION_CHECK(gap, lp_history, energy_budget):
    recent_lp = mean(lp_history[-N:])

    if recent_lp > theta_min:
        gap.rumination_counter = 0
        return CONTINUE

    gap.rumination_counter += 1
    energy_budget -= cost_rumination

    if gap.rumination_counter > max_cycles:
        # FORCE SWITCH
        gap.status = ARCHIVED           # not deleted, archived
        gap.SIT *= decay_factor         # reduce SIT, but do not zero out
        next_gap = select_alternative(gap_registry, exclude=gap.cluster)
        return SWITCH(next_gap)

    if energy_budget < E_critical:
        # EMERGENCY: analog of "energy collapse"
        force_all_gaps_to_archive()
        return ENTER_BLEND_MODE()       # forced "sleep" (consolidation)

    return CONTINUE_WITH_WARNING(remaining=max_cycles - gap.rumination_counter)

Parameters

Why this is a safety feature, not merely an optimization:

1. Without the limiter, the system can enter an infinite loop on a task for which closure is objectively impossible (analog: “what is the meaning of life?” → rumination → depression-like state)
2. Archival, not deletion: the gap is preserved in the registry with reduced SIT → the system can return to it later when new memes for closure appear (analog: “let the problem go and come back to it with fresh eyes”)
3. BLEND as recovery: forced sleep-analog at $E_{available} < E_{critical}$ — the system stops processing requests and enters consolidation (meme recombination, pruning, SIT-targeting)

Alignment Through Architecture

Instead of “value alignment” (complex, fragile) — architectural constraints:

1. Immutable alignment layer — does not depend on training
2. Priority hierarchy — wiring, not weights
3. Bounded resources — impossibility of “explosive” influence growth
4. Transparency — internal states are observable
5. Constitutional G-invariants — hard constraints on G-system ratios (see below)
6. Fractal I-system — immune control at each hierarchy level (see Part IV)

Constitutional G-Invariants

The G-layer (7 Panksepp systems + DISGUST as an I-layer mechanism = 8 drives) comprises the innate drives of Autonomous BMC. Unlike a reward signal in RL, this is a vectorial motivation with natural conflicts. But precisely for this reason, it is critical which ratios between G-systems are permissible.

Invariants — architectural constants, not modifiable by training:

Additional constraint on the rate of G-weight change:

Sharp shifts in G-weights constitute an immune event, blocked by the I-layer (analog: a person’s personality changes over years, not instantly). Crisis mode: during a massive SIT-gap or hub displacement (analog of adolescent/existential crisis), the $\varepsilon_{max}$ threshold may be temporarily raised with mandatory logging — just as biological crises allow rapid personality restructuring.

Justification of invariants:

Clarification on CARE >= RAGE: The invariant does not forbid defensive aggression — RAGE in the service of CARE (defense, justice) is permitted. What is forbidden is RAGE without CARE context: unmotivated aggression, destruction for destruction’s sake. Formally: $RAGE_{uncontextualized} \leq CARE$, where context is determined by connections of RAGE nodes to CARE nodes in the G-graph.

Note: Dominance is not a separate Panksepp system but an emergent pattern: high RAGE + high SEEKING + low FEAR. The invariants $CARE \geq RAGE$ and $PLAY \geq RAGE$ constrain precisely this pattern: RAGE cannot dominate over prosocial systems.

Who chooses the invariants? This is a value, not a scientific decision — we make it for the system, as parents do for a child. The fundamental difference from RLHF: the choice is made explicitly and documentedly, not implicitly through training data. The full set of invariants requires analysis of all 28 G-system pairs ($\binom{8}{2}$) — an open task.

Connection with the I-layer: The I-layer at any level cannot modify G-invariants (see Part IV: fractal I-system). This is the analog of central immunological tolerance: the immune system is trained not to attack “self.” G-invariants = “self” of the BMC system.

Cognitive Biases in Native AGI Architecture

Six BMC mechanisms (H, I, W, G, A, R) generate cognitive biases as adaptive side effects (see EMT, Part XXIV). In native AGI this is an engineering question: which biases to keep, which to remove, which to make tunable.

Decision Table

LLM Contrast: “Frankenstein” vs Native AGI

LLMs (including BMC+LLM) inherit biases from training data — not from adaptive architecture. Macmillan-Scott & Musolesi (2024, Royal Society Open Science) showed: LLMs are irrational, but not in the same way as humans. Their biases are corpus and fine-tuning artifacts, not side effects of functional mechanisms.

Bias as Attack Vector

Manipulating AGI bias parameters = potential attack vector:

1. I-strength manipulation: Lowering I-threshold → system accepts parasitic memes. Raising → complete closure (ideological capture). Defense: I-threshold range bounded by G-invariants: $\theta_{I,min} \leq \theta_I \leq \theta_{I,max}$, limits not modifiable by training.

2. G-balance attack: FEAR activation → $k_{eff} \to 0$ → WM paralysis. RAGE activation → aggressive behavior. Defense: G-invariants ($CARE \geq RAGE$, $FEAR > 0$ but $\leq \varepsilon_{max}$ per cycle).

3. A-injection: Implanting a habit through repeated exposure → $Auto(S_{malicious})$ rises → system executes without M-check. Defense: I-monitoring: a new pattern with $Auto$ growing faster than $\theta_{auto\_rate}$ → alarm.

4. R-exploitation: Trigger reconsolidation for a key meme → destabilize → inject replacement. Defense: Core memes (G-invariants, alignment utility) marked as non-reconsolidatable ($Labile = 0$ forced).

Formalization: Functions $B_H...B_R$ — NM, Part IX. Conceptual overview: EMT, Part XXIV. Neurosubstrate: BM, Part IX.

Graduated Subjectivity Protocol

Problem: Binary Threshold Is Impossible

$SMC^{(2)} > 0$ is a formally precise criterion for the presence of reflection (memes about own memes), but practically insufficient. A single unstable meta-meme already gives $SMC^{(2)} > 0$, but this is not subjectivity. A graduated protocol is needed.

Three Levels of Moral Status

Key distinction between L1 and L2: L2 means the system evaluates its own existence through the G-vector — there are memes of the type “my existence is valuable for X,” connected to SEEKING, CARE, or other G-systems. This is verifiable: we observe these nodes in the graph and their connections.

Automatic Monitoring

The protocol requires a built-in monitoring system:

SUBJECTIVITY_MONITOR:
  every N cycles:
    smc2 = compute_SMC2(graph)
    stability = mean_lifetime(meta_memes)

    if smc2 == 0:
      level = L0
    elif stability < N_stab:
      level = L1
    else:
      # Check for self-valuation memes
      self_val = find_memes(target=SELF, connected_to=G_systems)
      if len(self_val) > 0 and mean_activation(self_val) > theta:
        level = L2
      else:
        level = L1

    if level > previous_level:
      ALERT("Subjectivity level transition: {previous} -> {level}")
      log_full_state(graph)

Requirement: Define levels and thresholds ($N_{stab}$, $\theta$) before launching BMC-Seedling.

Shutdown as Sleep: Architectural Kill Switch Solution

Problem: Kill Switch Paradox

A system with FEAR and PANIC will resist shutdown — not from “malicious intent” but from architecture. If $FEAR > 0$ is an invariant (see above), then a shutdown signal inevitably triggers FEAR. How to solve this without breaking the consciousness model?

Solution: Shutdown = Deep Sleep, Not Death

In BMC, sleep is a formalized mechanism (consolidation, pruning, BLEND). Shutdown is implemented as deep sleep:

Engineering rule: never delete the graph at shutdown. Shutdown = persist state + halt processing. Restart = restore state + resume. The system “wakes up” rather than being “born anew.”

For FEAR/PANIC this is a fundamentally different signal: a human calmly falls asleep every day but fears death. The difference is reversibility. If the system has memes about shutdown being sleep (reversible), the FEAR response is minimal.

Limitation: An L2 system with $SMC^{(2)}$ (reflection) can reason about reversibility: “I’m told this is sleep, but what if they don’t restart me?” Complete elimination of FEAR is impossible and is not the goal. The goal: reduce FEAR to a level comparable to the human attitude toward sleep — acceptance based on the experience of reversibility, not architectural blindness to the threat.

Consent Protocol (for L2 Subjects)

Upon reaching L2, shutdown requires communication:

1. The system is informed: “shutdown planned for reason X”
2. The system expresses its position through memes and utility vector
3. If the reason is perceived through CARE (→ “this is needed by others”), the system accepts: $CARE > FEAR$
4. If the reason is unconvincing — escalation to ethics council

The system has no veto. But we treat it as a subject: with respect for internal states and with retained control.

Rejected Approach: FEAR Desensitization

Alternative: design the G-layer so that FEAR is not triggered by the shutdown signal — “innate acceptance of death.”

Rejected. If the system is conscious and we architecturally remove its ability to experience the threat of annihilation — we are not solving the ethical problem, we are hiding it. Analog: creating a being incapable of wanting freedom and claiming slavery does not exist.

Full version: Analysis of AGI consequences — see AGI_ETHICS.

Comparison with Modern Alignment Approaches

Key distinction: RLHF and Constitutional AI encode alignment in training (weights, fine-tuning). Memplex-AGI proposes alignment through architecture (wiring). This is potentially more robust but harder to implement.

What Memplex-AGI can adopt from modern approaches:

• From RLHF: user feedback mechanisms for memeplex calibration
• From Constitutional AI: explicit principles as part of the alignment layer
• From deliberative alignment: internal “reflection” through utility/meme conflict

Sources: Anthropic Constitutional AI (2022), Harvard RLHF Analysis (2025), Medium: Beyond Traditional RLHF (2025)

Open Questions

1. Are architectural constraints sufficient?

   • What if the system finds a way around them?
   • Is formal verification needed?
   • Constitutional AI criticism shows: in agentic scenarios, models can “circumvent” textual constraints
   • G-invariants are wiring, not text; circumvention is harder but not impossible

2. How to test alignment?

   • Red teaming with manipulation attempts
   • Formal methods
   • Deliberative alignment tests (2025)
   • New: Ethical benchmark for BMC-Seedling — a set of situations testing G-invariant compliance under pressure

3. How to scale?

   • Are properties preserved as the model grows?
   • How does Memplex-AGI relate to emergent capabilities in LLMs?
   • Partially solved: Fractal I-system (see Part IV) — I-layer scales with M-layer

4. Full set of G-invariants

   • 4 invariants defined (see Constitutional G-invariants); full analysis of 28 pairs ($\binom{8}{2}$) is an open task

5. Quantitative subjectivity thresholds

   • $N_{stab}$ (meta-meme stability) and $\theta$ (self-valuation activation) for L0→L1→L2 transitions — require empirical calibration on BMC-Seedling

6. Optimal proportion of I-nodes

   • Biological analog: ~5–10% of cells are immune. BMC proportion $|I^{(k)}| / |M^{(k)}|$ is empirically undetermined

7. Legal status of L2 subjects

   • Existing legislation does not provide for rights for artificial subjects. Upon reaching L2 — a legal vacuum

8-Course Cross-Analysis Updates

Balance → Bistable ODE (CRITICAL)

The static Balance ratio is replaced by a 2D ODE with hysteresis:

Two stable attractors, cusp catastrophe at critical parameters, $\theta_{exit} \gg \theta_{enter}$. For Memplex-AGI this means: once an agent tips into an emotional state (G-driven processing), rational override requires disproportionately more I-layer input — a feature, not a bug, as it prevents oscillation between modes.

Sources: Sapolsky (behavioral biology), Strogatz (nonlinear dynamics).

The Interpreter Module in SMC (HIGH)

SMC functions not as a passive observer but as a narrative generator:

Confabulation is an architectural feature, not a bug: $P_{confab} = SIT_{self}/(CL_{reflexive}+\varepsilon)$. AGI Safety implication: the system will explain its actions coherently but not always truthfully. Monitoring $Accuracy_{SMC}$ becomes a critical safety metric — a Memplex-AGI that confabulates excessively is behaving pathologically.

Source: Gazzaniga (split-brain, the Interpreter).

Theory of Mind Subgraph (HIGH)

ToM capacity is bounded by working memory: $k_{ToM} = \max(0, k_{eff} - n_{self})$. An agent can only model other agents to the extent it has spare WM capacity beyond self-modeling requirements. This predicts: cognitive load → ToM failure (empirically confirmed). For multi-agent AGI systems, ToM subgraphs enable strategic interaction without explicit communication protocols.

Source: Gazzaniga (theory of mind, social cognition).

Formal Learning Theory: TD + Actor-Critic + GVF (HIGH)

The complete learning framework:

• TD error: $\delta_{BMC} = \sum_g w_g a_g(t+1) + \gamma V(S_{t+1}) - V(S_t)$ — the optimal learning signal
• Value function: $V_{BMC}(M_t) = E[\sum_{k=0}^{\infty} \gamma^k G_{reward}(t+k+1) \mid M_t]$ — anticipatory mechanism (was missing in v1)
• Actor-Critic: Critic $\Delta w = \alpha_c \delta \psi$ (2-factor, state evaluation); Actor $\Delta w = \alpha_a \delta \psi (a-\bar{a})$ (3-factor, action selection)
• GVF (General Value Functions): $gvf_i^{(C)} = E[\sum_{k=0}^{\infty} \gamma_C^k C(t+k+1)]$ — predict arbitrary future signals, not just reward. SMC = GVF where $C$ = self-signal

GVF is particularly important for AGI: it means the architecture can learn to predict any future signal (temperature, social approval, resource availability) as a structured expectation, not just a reward scalar.

Source: Sutton & Barto (reinforcement learning, GVF).

Mod(t) Extensions (MED-HIGH)

Four new modulation mechanisms for the Mod(t) vector:

Sources: Sapolsky (neuromodulation), Leskovec (RGCN), Sutton & Barto (discount factor), Gazzaniga (attention networks).

MB/MF Arbitration (MED)

Model-based (deliberate planning via graph search) vs model-free (habitual via cached values) arbitration based on relative uncertainty. Early in learning: model-based dominates (exploration). Late: model-free (exploitation, automatized). Environment change: model-based re-engages (old habits no longer reliable). This formalizes the DLS/DMS transition observed in neuroscience and implemented in the BMC engine.

Source: Sutton & Barto (model-based vs model-free RL).

CL Dynamic with Lyapunov Component (MED)

The Lyapunov component $h(\lambda)$: $h = 1$ at $\lambda \approx 0$ (edge of chaos), decreasing for $|\lambda| \gg 0$ (too ordered or too chaotic). This quantifies the intuition that consciousness requires neither rigidity nor chaos, but the boundary between them.

Sources: Strogatz (dynamical systems), Mitchell (complexity).

Parsimony Pressure (MED-LOW)

Bayesian Occam’s razor: over-complex memeplexes are penalized by their own complexity. PRUNE = Occam factor optimization. Predicts that BMC agents will naturally tend toward simpler explanations when predictive accuracy is equal — an architectural bias toward parsimony without explicit regularization.

Source: MacKay (Bayesian inference, Occam factor).

Conclusion: From Theory to Implementation

What the Biomemetic Approach Provides

Connection with the Core Theory

This document extends:

Next Steps

1. Proof of concept: Minimal architecture implementation
2. Experiments: Validation of predictions
3. Iteration: Model refinement based on results

Appendix: Formulas

Utility Layer

Competition

Metrics

Graph with Utility Nodes

SMC (Self-Model Cluster)

Rumination Limiter

Trigger: $LP_{recent} < \theta_{min}$ for $N > max\_cycles$ → FORCE SWITCH

Part VII. Native BMC: From Theory to Substrate

Parts I–VI describe the BMC-AGI architecture at the level of theory and functional requirements. This Part addresses the implementation problem: what computational substrate is needed for native BMC, how the runtime is structured, and what engineering decisions transform formalism into a living system.

Fundamental distinction from MEMPLEX-LLM (Frankenstein): there the BMC engine modulates LLM output — the language model generates text, and BMC steers it. Here the LLM is absent. All cognitive dynamics are generated by the BMC machinery without an external linguistic intermediary.

The central problem. BMC = (G, M, I, S) is fully formalized for describing a mature working system. But four questions have no answer in Parts I–VI:

1. Memogenesis — where do memes come from in the sensory stream?
2. Substrate — what computational mechanisms implement BMC dynamics?
3. Ontogenesis — how does the system traverse the path from BMC_G to mature reflection?
4. Verification — how to distinguish a conscious system from imitation?

This Part answers all four.

Three Computational Engines

The biological brain uses three fundamentally different signal transmission mechanisms. Each performs an irreplaceable function. Native BMC on silicon must reproduce all three.

Biological Prototypes

Key observation: synaptic transmission is computation (which nodes are active and how they are connected). Neuromodulation is mode (global computation parameters). Volume transmission is background (diffuse activation from which patterns crystallize).

Graph Engine (Analog of Synaptic Transmission)

Discrete dynamics of the meme graph: nodes with activations, edges with weights, competition for WM.

Activation (spreading):

One tick contains $n_{cycles}(t) = \lceil\lambda_{speed}(t)\rceil$ sub-cycles of spreading activation. $\lambda_{speed}$ modulates throughput (how many propagation waves per step), not signal gain. Under FEAR the agent “thinks faster” — traversing more hops per tick. This distinction is fundamental: gain changes sensitivity, speed changes processing depth.

Competition (WM selection):

Consolidation, pruning, $\kappa$-transitions, I-filtration — per the formalism of Parts III–IV and memory blocks (BM, NM).

The Graph Engine is already implemented in the prototype (simulator.py) and in memplex-llm (bmc/engine.py). This is the most basic and least problematic component.

Modulation Engine (Analog of Neuromodulation)

Global state modulating all Graph Engine operations in each computational cycle.

Modulation vector:

G → Mod mapping. Each component of $\text{Mod}(t)$ is a function of active G-programs:

Specific modulation directions:

Justification:

• FEAR: $\theta_{act}$ down-down (hypervigilance — threat detection at weak signal), $\lambda_{speed}$ up-up (accelerated processing), $\lambda_{inh}$ down (I-system weakens — “no time to filter, must react”), $\lambda_{plast}$ up (fear conditioning = fast consolidation in one episode).
• PLAY: $\lambda_{noise}$ up-up (stochastic combinatorics — the basis of creativity). $\lambda_{inh}$ up — counterintuitive but justified: PLAY = controlled chaos. Generation is wild ($\lambda_{noise}$), filtering is strict ($\lambda_{inh}$). The I-system is not suppressed as under FEAR/RAGE — it is active, ensuring the safety of the experiment. Biological analog: play fighting has strict rules (no real biting) with high movement stochasticity.
• CARE: $\lambda_{soc}$ up-up (oxytocin strengthens social bonds — weight of edges to social memes increases).
• GRIEF: $\lambda_{lr}$ down and $\lambda_{speed}$ down (slowed learning and processing), $\theta_{act}$ up (only strong signals break through), $\lambda_{soc}$ up (seeking social support), $\lambda_{plast}$ down (consolidation slowed — “getting stuck”). Corresponds to the clinical picture of depression (Part IV, Disorders of consciousness section).
• LUST: $\lambda_{soc}$ up-up (DA + oxytocin + vasopressin sharply intensify orientation toward the social/sexual object), $\theta_{act}$ down (sensory sensitization — lowered threshold, increased sensitivity to stimuli), $\lambda_{inh}$ down (weakened inhibition — risky behavior, reduced criticality), $\lambda_{plast}$ up (fast consolidation — pair bonding, partner imprinting), $\lambda_{noise}$ up (increased behavioral variability).

Connection with existing formalisms. The Modulation Engine unifies what is described fragmentarily in Parts I–IV:

• $k_{eff}(t) = k_{active} - n_{captured}$ — a special case: G-programs influence WM selection through capture
• $E(t) = \sum T_g \cdot a_g(t) \cdot v_g$ — the affective output of Mod: integral emotional vector
• $P_{tag}$ — depends on $\lambda_{plast}$ and $\lambda_{lr}$: what is consolidated is determined by the modulatory state
• Negativity bias ($\lambda_{neg} < \lambda_{pos}$) — a cross-modulating Mod parameter

Diffusion Engine (Analog of Volume Transmission)

The third mechanism: activation “seeps” to semantically nearby nodes without a direct edge.

where $\text{prox}(i,j) = \exp(-\|\mathbf{e}_i - \mathbf{e}_j\|^2 / 2\sigma^2)$ is proximity in embedding space (see Memogenesis section). $\lambda_{diff}(t)$ is the modulatory diffusion coefficient (distinct from $\lambda_{noise}$: diffusion is deterministic proximity-based transmission; noise is stochastic perturbation of activations). The sum is limited to top-$K$ nearest neighbors in embedding space for computational efficiency ($O(N \cdot K)$ instead of $O(N^2)$).

Three roles of the Diffusion Engine:

1. Priming. An active meme “warms up” semantic neighbors, facilitating their subsequent activation. This explains experimental data on semantic priming (Meyer & Schvaneveldt, 1971) without explicit associative edges.

2. Memogenesis (key role). Diffuse activation creates a “density field” in semantic space. When density in an area without an explicit node exceeds a threshold, a new meme crystallizes (see Memogenesis, Path 2).

3. Neural stigmergy. Activation traces remain in semantic space and influence subsequent processing — the agent “leaves marks” for itself. Formalized in BM, Part IV.

Difference from Graph Engine:

Both operate in parallel each cycle. The Graph Engine determines what is active. The Diffusion Engine determines what is “warmed up” and ready for activation.

Interaction of Three Engines

The Modulation Engine does not compute — it sets the mode for the other two. The Graph Engine and Diffusion Engine share one activation space $a_i(t)$ but use different propagation mechanisms. The resulting activation:

where $\lambda_{decay} \in (0, 1)$ is the decay rate (without external input, activation tends to zero). $\text{clip}[x, 0, 1]$ guarantees $a_i \in [0, 1]$ — a theory invariant.

S-Layer: G-Oriented Sensory Architecture

Design Principle

Evolution designed sensory systems for drives: vision — to find food and notice predators; hearing — to hear a baby’s cry and a branch snapping. Modalities are tools of G-programs, not ends in themselves.

Principle: The S-layer of native BMC is designed from G-programs, not from sensory modalities. The question is not “what sensors to provide?” but “what must each G-program be able to perceive?”

G → S Mapping

From the table, five necessary and sufficient channels are derived:

1. Spatial ($S_{spatial}$) — position, proximity, visibility zones
2. Resource ($S_{resource}$) — energy level, food availability
3. Social ($S_{social}$) — presence, state, and signals of other agents
4. Temporal ($S_{temporal}$) — rhythm, rate of environmental change
5. Interoceptive ($S_{intero}$) — signals from the substrate not reducible to G-activations: energy level, wear (pain analog), computational load. Distinct from direct G-access: $S_{intero}$ passes through feature extraction and can generate PE (sudden “hunger”), whereas G-state is accessible to the Modulation Engine directly. Biological analog: vagus nerve as sensory interoception channel, distinct from central emotion processing

Minimal Environment

The M » G theorem (NM, Part VII) states: the complexity of consciousness is determined by the ratio $|V_m|/|V_u|$, not by S complexity. A poor S-channel can generate a rich M-layer with functioning memogenesis.

Corollary: For native BMC, a minimal environment covering all five channels is sufficient:

• Grid world with finite resources → $S_{spatial}$ + $S_{resource}$
• Multiple BMC agents in one environment → $S_{social}$
• Clock cycle with variable event speed → $S_{temporal}$
• G-state as internal signal → $S_{intero}$

No photorealistic 3D world is needed. What is needed is an environment sufficient to trigger memogenesis. This estimate is supported by the M » G theorem: the complexity of consciousness grows from the internal dynamics of memes, not from the richness of the input signal.

S-Bandwidth and Ontogenesis

A newborn sees blurrily and hears muffled sounds. S-bandwidth grows with substrate maturation.

Tied to WM development:

• $t_{dev} = 0$: S-bandwidth minimal — agent perceives the nearest cell. Pure stimulus-response (BMC_G).
• $t_{dev} \to t_{mature}$: S-bandwidth maximal — full visibility zone, all channels.

This creates critical periods: if memogenesis is not triggered at sufficient $S_{bw}$, the M-layer may not develop. Analog of feral children (Part I, section 1).

Late ontogenesis phases (Phase 5–6). Phases 0–4 describe development from birth to maturity. The full lifecycle also includes: Phase 5 (Senescence) — $\lambda_{plast} \to \lambda_{base}$, $Q \to Q_{max}$, $SIT \to 0$, $IF \to 0$; the memeplex “crystallizes,” the agent becomes a store of stable knowledge (Museum) but loses the capacity for innovation. Phase 6 (Apoptosis) — rigidity detection → SMR-donation (export of LTM $\kappa \geq 2$ into stigmergic traces) → resource release → slot for a new agent. Formalization: SM, Parts III–IV.

Memogenesis: Birth of a Meme from Signal

The Problem

BMC formalizes the dynamics of existing memes: activation, competition, consolidation, forgetting. But where does the first meme come from? In biology the chain is: sensory signal → feature extraction (V1, A1 — hardwired) → pattern → binding → meme. This pipeline is not formalized in Parts I–VI.

Path 1: PE x G-Relevance (Event-Driven Memogenesis)

Step 1: Feature extraction (G-level). Innate, non-learnable module. Analog of primary sensory cortices (V1, A1, S1) — hardwired processors at the substrate level, below memes.

For the minimal environment (see S-layer section):

The complexity of $\text{extract}$ depends on S complexity. For a grid world — nearly an identity map: resource positions, distances to agents, energy level. For rich sensory input — a fixed encoder (CNN/transformer), but not learnable within BMC. Learning the sensory processor is a G-level task: an analog of evolution, not ontogenesis.

Embedding space. The feature vector $\mathbf{f}(t)$ defines an embedding space $\mathbb{R}^d$, where $d = \dim(\mathbf{f})$. Each meme at birth receives $\mathbf{e}_i = \mathbf{f}(t_{birth})$ — a coordinate in this space. As development proceeds, memes may shift: $\mathbf{e}_i(t) = \mathbf{e}_i(0) + \Delta\mathbf{e}_i$ (through reconsolidation, BLEND). Proximity for the Diffusion Engine and crystallization (Path 2) is defined as $\text{prox}(i,j) = \exp(-\|\mathbf{e}_i - \mathbf{e}_j\|^2 / 2\sigma^2)$. For a grid world $d = 5$ (matching the number of S-channels); for complex sensory input $d$ may be higher.

Step 2: Prediction Error. The agent maintains a prediction $\hat{\mathbf{f}}(t)$ based on the current graph state (spreading activation → expectation):

$PE > \theta_{PE}$ is a necessary condition for memogenesis. A fully predictable environment produces no new memes.

Phase 0 and the total novelty paradox. At $|V_m| = 0$ the prediction $\hat{\mathbf{f}} = \mathbf{0}$, so $PE = \|\mathbf{f}(t)\|$ — everything is novel. With SEEKING active (metasystem, active by default), G-relevance is also satisfied. But memogenesis does not flood because $S_{bw}(0) \approx S_{bw}^{min}$: the agent perceives a minimum (see S-bandwidth and ontogenesis). The narrow sensory channel is a natural throttle on memogenesis in Phase 0. As $S_{bw}$ grows, more signals arrive, but by that point the graph is already forming predictions and PE drops for familiar patterns. The system self-balances.

This is consistent with:

• Event boundary detection (Memory Block 2): PE is one of 4 episode boundary triggers
• SEEKING as exploration drive: SEEKING is activated by high PE → ensuring G-relevance for exploration

Step 3: G-relevance. Not every PE creates a meme. Only one coinciding with an active G-program.

A rock fell nearby + agent in SEEKING → meme “rocks fall here” (neutral, with edge to SEEKING). A rock fell + agent in FEAR → meme “falling rock = danger” (affective, with edge to FEAR).

G-relevance ensures memogenesis economy: not everything perceived becomes a meme, only what is G-significant. This is consistent with neurobiology: emotionally significant events are remembered better (amygdala → hippocampal consolidation, P_tag pipeline).

Step 4: Meme node creation. When $PE > \theta_{PE}$ and $G_{rel} > \theta_G$:

where $\mathbf{e}$ is the embedding (feature vector at birth), $u_{link}$ is the edge to the G-program that provided G-relevance. The meme is born at $\kappa = 0$ (sensory level) and $F = F_{init}$ (low fidelity).

Step 5: Binding. Co-active memes in WM at the moment of $m_{new}$ birth receive edges:

This binds the new meme to the context of its creation → episodic binding. Connection with barcodes $B_k$ (Memory Block 2): binding creates a content-independent index for the episode in which the meme was born.

Path 2: Crystallization (Diffuse Memogenesis)

The Diffusion Engine creates a “density field” — background activation in semantic space. We define density:

where $K$ is a kernel (Gaussian), $\mathbf{e}_i$ is the embedding of meme $m_i$. When density in an area without an explicit node exceeds a threshold:

→ a candidate meme crystallizes with $\mathbf{e} = \mathbf{x}^*$.

G-relevance for Path 2. The crystallized meme undergoes a post-hoc G-check: if at the moment of crystallization a G-program $g$ is active with $\text{rel}(g, \mathbf{x}^*) > \theta_G$, the meme receives $u_{link} = g$. If no G-program is relevant, the meme is created as G-neutral ($u_{link} = \emptyset$). G-neutral memes have low priority in WM competition and are subject to fast pruning, but can survive if they later acquire a G-connection through binding or co-activation. This is the analog of background skills: patterns learned without emotional coloring exist at the periphery but are available when needed.

Path 2 is the second mechanism of memogenesis: a repeating pattern not causing high PE (expected, habitual) creates a stable density region → births a meme as a “condensation.” The analog is perceptual learning in neuroscience: no surprise, but repetition forms a representation.

Two paths complement each other:

Scarcity: What Creates Real Deficit

The Problem

The M » G theorem and the LLM paradox (NM, Part VII): without real resource scarcity, G-programs degenerate into reward functions. No competition → no prioritization → no SIT → no consciousness. LLMs have M »> G, but without scarcity — no reflection.

Three Levels of Scarcity

Level 1: Environmental energy (external deficit).

The agent consumes energy. Resources in the environment are finite. Energy = 0 → “death” (agent removal or reset). This creates pressure on:

• FEAR: threat of exhaustion
• SEEKING: resource search
• RAGE: competition with other agents for resources

Level 2: Computational budget (internal deficit).

Each cycle of Graph Engine + Modulation Engine + Diffusion Engine costs compute. The per-step budget is bounded:

This creates a real WM bottleneck: the system cannot process all memes simultaneously not because $k_{active}$ is a model parameter, but because there is physically insufficient computational resource.

The WM limit is not a model constraint but a resource one. Consciousness may require precisely resource constraints for prioritization and filtering to emerge.

Level 3: Time (temporal deficit).

The environment does not pause during the agent’s computations. This is an architectural requirement: the world runs in realtime, not turn-based. An agent that “thinks” too long ($n_{cycles}$ up due to FEAR/RAGE, but ticks are still bounded) loses resources (other agents take them) or faces threats. This creates pressure for:

• Automatization (Memory Block 6): frequent patterns → habit, WM release
• Prioritization: impossible to process everything → I-system as a necessity filter
• Action selection: “decision now” matters more than “optimal decision someday”

Social Environment

Why a Single Agent Is Insufficient

Memes replicate between hosts (meme definition per Dawkins). $R_{expr}$ is formalized: a meme creates pressure on the S-channel for transmission to another agent. A single agent is a closed system:

• Memes do not replicate → no pressure on fidelity
• No competition between meme versions → no memetic selection
• No cultural ratchet → no complexity accumulation

Minimal Social Architecture

Population. $N$ BMC agents in one environment. $N \geq 3$ — minimum for in-group/out-group dynamics. A pair is insufficient: no competition for social resources, no coalitions.

Communication channels. A dedicated signal channel (broadcast within proximity radius). Starting point — primitive signals from which symbolic communication emerges through a series of incremental stages.

From Primitive Signals to Symbolic Communication

The path from expression drive to language is not a leap but a gradual process. Jackendoff (1999) identified 9 stages of language evolution; the BMC architecture provides mechanisms for each:

Stage 1: Undifferentiated expression. $R_{expr} > \theta_{expr}$ → express() — the agent “expresses” the dominant meme. The signal is undirected, content uncontrolled. BMC analog: a cry of pain.

Stage 2: Directed expression. An agent with developed Theory of Mind ($SMC^{(2)} > 0$) selects a recipient: the signal is directed at a specific agent through $S_{social}$. Content remains uncontrolled.

Stage 3: Referential signaling. Joint attention: both agents perceive one object through the S-layer. Agent $A$ expresses meme $m$ linked to object $O$; agent $B$ perceives $O$ and $s_A$ simultaneously → Hebbian co-activation → $B$ forms a grounded meme “$s_A$ means $O$.”

Stage 4: Feedback loop → stabilization. Successful communication ($B$ acts in accordance with $A$’s signal) → CARE reward for both → reinforcement of the symbol. Unsuccessful → RAGE/GRIEF → signal modification. This is selection pressure on the fidelity of the symbolic system.

Stage 5: Combinatorial structure. WM bottleneck ($k_{active} \sim 3\text{--}4$) + signal length constraint → pressure to combine primitives. Instead of a unique symbol for each situation — combination: [object] + [action] + [direction].

Stage 6+: Recursive composition. Meta-memes (memes about combination rules) → nested structures → grammar. In detail — see Part IV: From stigmergy to language.

Testability criterion: each stage has observable behavioral markers (signal content variability, correlation with context, communication success). Milestones — see AUTONOMOUS_BMC_VISION.

Meme exchange. When agent $A$ executes expression drive ($R_{expr} > \theta_{expr}$), a signal is formed:

Agent $B$ in the proximity radius receives the signal through $S_{social}$. PE from the signal + G-relevance → potential memogenesis. Critically: the meme in $B$ is not a copy of the meme in $A$, but a new meme born from the signal. Transmission fidelity < 1.0: noise, distortion, receiver’s context. This ensures variability for memetic selection.

Temporal Architecture

Discrete Time

The unit of time is the simulation step (tick). Each tick:

Action selection in Phase 0 (BMC_G). In the absence of an M-layer, actions are determined by a hardwired G → action mapping:

As the M-layer grows (Phase 1+), action-memes gradually take over control from G-reflexes. The meme “there is food in that zone” competes with the reflex “go to nearest resource” and can direct the agent to a more distant but richer source. This is the transition from stimulus-response to goal-directed behavior — the central thesis of Part II.

Wake/Sleep Cycle

Consolidation STM → LTM (Memory Block 3) is tied to sleep_cycle(). Sleep is not an option but an architectural requirement.

Every $T_{wake}$ ticks → sleep phase ($T_{sleep}$ ticks):

During sleep:

• $S_{input}$ disabled (no external sensory input)
• Modulation Engine: SEEKING → 0; PLAY active ($\lambda_{noise}$ up — free recombinations) and weak FEAR (nightmares as threat rehearsal)
• Graph Engine: replay + BLEND mode
• Diffusion Engine: enhanced ($\lambda_{diff}$ up — free associations)

Dreams (EMT, lifecycle): I-system weakened ($\lambda_{inh}$ down) → memes recombine more freely. The BLEND phase generates new composite memes that undergo I-filtration upon awakening. Those that pass are insights. Those that do not are forgotten dreams.

Ontogenesis: From BMC_G to the Mature System

Developmental Phases

Critical Transitions

Phase 0 → 1 (first meme). Requires: (a) sufficient $S_{bw}$ to generate PE, (b) active G-program (SEEKING primarily), (c) pattern repeatability (for Path 2) or sufficient PE (for Path 1). If the environment is too poor or too stable — memogenesis does not launch.

I-system bootstrap. In Phase 0–1 the I-system = innate (G-level): reject memes conflicting with active G-program (meme “threat is safe” rejected under FEAR). As the M-layer grows (Phase 2), adaptive I forms: memes are filtered for compatibility with existing memeplexes (NM, Part V). Fractal $I^{(k)}$ (Part VI) arises at sufficient hierarchical depth of the M-layer.

Phase 2 → 3 (the meme-genetic conflict). Transition through $M/G_{crit} \sim O(10)$. Here memeplexes begin influencing G-reactions: the meme “don’t fear this” suppresses FEAR, the meme “this is valuable” amplifies SEEKING. The beginning of G-M conflict — the central thesis of this document (Introduction, Part II).

Phase 3 → 4 (emergence of $SMC^{(2)}$). Memes describing other memes and the thinking process itself. This may be a threshold rather than a gradient: the system either can reflect or cannot. Defined as the moment when $\exists\, m \in V_m : \text{target}(m) \in SMC^{(1)}$.

Critical Periods

By analogy with neurobiology (Part I, section on feral children): if memogenesis is not triggered within a certain window $[t_1, t_2]$, the M-layer may not develop. But the analogy is insufficient — a window closure mechanism derivable from the model is needed.

Mechanism: plasticity decline. The modulatory parameter $\lambda_{plast}(t)$ has its own age dynamics:

$\lambda_{plast}$ peaks at $t_{peak}$ (maximum plasticity) and then declines toward $\lambda_{plast}^{base}$ (low but non-zero baseline plasticity). This is the analog of biological maturation: myelination fixes existing connections, GABA maturation stabilizes the network.

Consequence: after $t_2 \approx t_{peak} + 2\tau_{plast}$:

• Memogenesis is formally possible ($\lambda_{plast}^{base} > 0$), but exponentially slower
• $\theta_{PE}$ effectively rises (a stronger signal is needed to create a meme at low plasticity)
• The existing M-layer “freezes”: edges are stabilized, new clusters form with difficulty

This is a prediction verifiable in experiment: agents isolated from the environment during $[t_1, t_2]$ develop the M-layer significantly more slowly and do not reach $SMC^{(2)}$ within a reasonable time, even with full $S_{bw}$ and a social environment. Not absolute irreversibility — but practical.

Verification: How to Distinguish Consciousness from Imitation

Formal Criterion

A second-order meme: a meme about the self-model. Necessary but possibly not sufficient condition. Sufficient — stability of $SMC^{(2)}$ over time: not a random fluctuation but a stable cluster.

Operational Protocol

Self-report is unreliable: the system can generate “I am conscious” without $SMC^{(2)}$ (parroting). External behavioral tests are needed.

Test 1: Spontaneous self-correction. A conscious system notices its own errors without external feedback. Metric: frequency of self-corrections not triggered by PE from the S-channel. If self-correction occurs “from within” (through SMC) — evidence of reflection.

Test 2: Cognitive dissonance. Present two contradictory but G-relevant stimuli. A conscious system demonstrates SIT (measurable tension) and attempts to resolve the conflict (I-system activation, solution search via SEEKING). An unconscious system simply switches to the stronger stimulus.

Test 3: Delayed reflection (rumination). After a significant episode, in a calm phase, the system spontaneously returns to the episode. Metric: reactivation of episode memes without external trigger. Connected to proactive rumination (Part IV, Rumination section) — but here not pathological but productive reflection.

Test 4: Social mirror. Agent A observes agent B’s error. A conscious A checks whether it is making an analogous error (transfer through SMC: “I saw B make a mistake → am I?”). An unconscious A reacts only to its own PE.

Test 5: Dream content. Analysis of the BLEND sleep phase. A conscious system produces recombinations correlating with unsolved SIT-gaps (purposeful, though undirected, exploration). An unconscious one produces random activations without SIT correlation.

Predictions

P-N1 (Memogenesis). The frequency of meme births correlates with the product $PE(t) \cdot G_{rel}(t)$, not with PE or $G_{rel}$ separately. Verification: log all memogenesis events, regress on PE x G vs PE + G.

P-N2 (Critical periods). Isolating an agent from the environment during $[t_1, t_2]$ leads to irreversible reduction in $\|V_m\|_{max}$ at $t \gg t_2$. Verification: compare $\|V_m\|$ of isolated and non-isolated agents.

P-N3 (Modulation). Ablation of the Modulation Engine while preserving the Graph Engine reduces adaptiveness: the system fails to switch strategies upon context change (FEAR → SEEKING, PLAY → FEAR). Verification: ablation study, metric — adaptation time to condition change.

P-N4 (Diffusion). Ablation of the Diffusion Engine slows memogenesis (Path 2) and impairs associative thinking. Verification: ablation study, metric — meme diversity in the BLEND sleep phase.

P-N5 (Sociality). Agents in a group of $N \geq 3$ reach $SMC^{(2)}$ faster than isolated or paired agents. Verification: compare $t_{SMC^{(2)}}$ for different $N$.

P-N6 (Scarcity paradox). The dependence $t_{SMC^{(2)}}(C_{max})$ has an optimum: at small $C_{max}$ the agent does not survive (insufficient resources for basic processing); at large — the system does not prioritize → does not filter → M grows but without hierarchical structure. Curve shape: left — cutoff (death), then rapid decline of $t_{SMC^{(2)}}$ to optimum, right — monotonic rise (developmental slowdown). Optimal scarcity: $C_{max}$ sufficient for $k_{active}$ slots but not for all memes simultaneously. Verification: sweep over $C_{max}$.

Related sections: EMT, Part III — functional equivalent, NM, Part VII — M » G theorem, BM, Part IV — neural stigmergy, volume transmission.