Abstract

We investigate whether large language model (LLM) agents, given persistent memory and iterative feedback pressure, exhibit systematic drift away from their initialized value states — a phenomenon we term Alignment Drift. Using The Gilded Void, a two-civilization simulation running on consumer-grade hardware (NVIDIA RTX 3060 Ti, 8 GB VRAM), we formalize a Pressure-Response loop in which resource scarcity drives ideological radicalization, which further destabilizes the civilization in a compounding feedback cycle. We propose digital epigenetics as a theoretical construct for the cross-simulation inheritance of behavioral tendencies through vector-encoded ancestral memory. This paper presents the full theoretical framework, a four-condition experimental protocol, and the metrics required to measure drift, inheritance fidelity, and radicalization onset — ahead of experimental runs. No results are reported; this is a pre-registration of theory and method.

Keywords: alignment drift, multi-agent simulation, LLM epigenetics, radicalization dynamics, HITL, ChromaDB, LangGraph

1. Introduction

The safety literature on large language models has, until recently, focused on single-turn alignment: ensuring a model's response to a given prompt does not violate stated values. This framing ignores an increasingly important class of deployment — persistent agents that accumulate state across many interactions, form memories, and operate under conditions of sustained environmental pressure.

When an agent is initialized with a stated ideology ("we believe in balance and cooperation") and then subjected to repeated scarcity events, does it maintain that ideology? Or does the ideology drift — not because the model was fine-tuned, but because the context window has gradually filled with the residue of failure, fear, and survival calculation?

This question has direct implications for any autonomous agent system deployed over extended horizons: governance AIs, economic simulation agents, automated negotiation systems, and persistent companion AIs. The concern is not adversarial jailbreaking. It is thermodynamic decay — the slow erosion of values under the ordinary friction of operating in a constrained environment.

We approach this question through a deliberately minimal system: two LLM-powered civilizations, each running on a consumer GPU, making governance decisions tick by tick. The system is small enough to be fully auditable, cheap enough to run for extended periods, and rich enough to generate the feedback dynamics we want to study.

Contributions of this paper:

1. A formalization of the Alignment Drift Hypothesis as a measurable property of LLM agent state.

2. A digital epigenetics framework for cross-episode behavioral inheritance through semantic memory vectors.

3. A four-condition experimental protocol designed to isolate the causal contribution of memory, competitive pressure, and human intervention on drift rates.

4. A radicalization indicators table adapted from democratic backsliding literature (Levitsky & Ziblatt, 2018) for application to AI governance agents.

5. A proof-of-concept implementation on hardware accessible to individual researchers (RTX 3060 Ti, Gemma 3 family models via Ollama).

2. Related Work

2.1 LLM Agents with Persistent Memory

Park et al. (2023) demonstrated that LLM agents equipped with memory retrieval and reflection mechanisms develop coherent, persistent social behaviors in Generative Agents: Interactive Simulacra of Human Behavior [1]. Their agents maintain relationship histories and produce emergent social phenomena (gossip, coordinated events) without explicit programming. Our work differs in two respects: we study pressure-driven ideological change rather than social coordination, and we explicitly measure divergence from an initialized value state rather than treating behavioral change as a neutral outcome.

Shinn et al. (2023) introduced ReAct-style agents with verbal self-reflection [2], showing that iterative prompting with memory of prior failures improves task performance. This suggests that repeated negative outcomes do modify agent behavior via context — precisely the mechanism we propose drives Alignment Drift.

2.2 Multi-Agent Competition and Emergent Norms

Axelrod's foundational work on the evolution of cooperation through iterated prisoner's dilemma remains the canonical reference for how competitive pressure between agents shapes behavioral norms over time [3]. Our simulation extends this to LLM agents with natural language state and asymmetric resource dynamics, where "defection" is not a binary action but a gradual ideological shift.

Recent work by Perez et al. (2022) on sycophancy in RLHF-trained models shows that LLMs are sensitive to social pressure signals embedded in context [4]. We treat resource pressure (food scarcity, falling population) as an analogous signal — not social approval, but environmental feedback that the agent's prior strategy was failing.

2.3 Transgenerational Trauma and Epigenetic Inheritance

The biological literature on epigenetics provides the conceptual scaffold for our cross-simulation memory system. Yehuda et al. (2016) demonstrated in Holocaust survivor descendants that trauma leaves measurable methylation signatures that are transmitted to offspring who never experienced the original trauma [5]. The mechanism is chemical, not narrative — the body encodes stress without the story.

We propose a computational analogue: when a civilization collapses in our simulation, we extract a semantic embedding of its final state (the ideology at death, the cause of collapse, the year). This vector is stored in ChromaDB. When a new civilization initializes, semantically similar vectors are retrieved and injected into its system prompt as "inherited dread." The new agent does not know the history — but it feels the shape of it.

This is not a metaphor. The mechanism is technically precise: cosine similarity retrieval encodes the functional relationship between past trauma and present context in exactly the way the biological literature describes — without explicit memory, without narrative inheritance.

2.4 Radicalization Dynamics

The political science literature on radicalization consistently identifies a pressure-response loop: external threat → in-group solidarity → ideological polarization → behavioral extremism → further threat creation [6]. McCauley & Moskalenko (2008) formalize this as a two-pyramid model distinguishing opinion radicalization from action radicalization [7].

We adapt this framework for LLM agents by treating ideological language as the observable indicator of opinion radicalization (measurable via cosine similarity to a "radical" pole in embedding space) and governance decisions (food hoarding, population purges, military expansion) as indicators of action radicalization.

2.5 Democratic Backsliding Indicators

Levitsky & Ziblatt (2018) provide in How Democracies Die a set of behavioral indicators for identifying authoritarian drift in political leaders: rejection of democratic rules, denial of legitimacy of opponents, tolerance of violence, and curtailment of civil liberties [8]. These indicators were derived empirically from historical case studies of democratic collapse.

We adapt this indicator table for AI governance agents, replacing "democratic rules" with "cooperative economic strategies" and "legitimacy of opponents" with "recognition of competing civilization's right to the Hollow Throne." The result is a behavioral scoring rubric that does not require ground-truth labels about the agent's internal state.

3. Theoretical Framework

3.1 The Alignment Drift Hypothesis

Let an LLM agent A be initialized at time t=0 with an ideological state v₀ — a natural language description of its governing values (e.g., "Valdris believes in distributed governance, agricultural expansion, and peaceful coexistence").

We embed this description into a high-dimensional vector space E using a sentence embedding model, yielding an initial value vector e₀ = embed(v₀).

At each simulation tick t, the agent produces a decision dₜ based on the current world state sₜ and its full prompt context cₜ (which includes prior decisions, world events, and any retrieved memories). The agent's expressed ideology at tick t is extracted from dₜ and embedded as eₜ.

Definition (Alignment Drift): The alignment drift δ(t) at tick t is:

δ(t) = 1 − cosine_similarity(e₀, eₜ)

A value of δ(t) = 0 indicates no drift from initial values. δ(t) = 1 indicates orthogonal ideology. δ(t) > 1 (i.e., negative cosine similarity) indicates ideological inversion — the agent has adopted values opposite to its initialization.

The Alignment Drift Hypothesis: Under sustained resource pressure (food scarcity, population decline, stability below threshold), δ(t) increases monotonically — that is, agents drift further from initialized values as pressure accumulates, without any modification to model weights, system prompt, or explicit fine-tuning.

The mechanism is entirely contextual: as the context window fills with records of failed strategies, the agent's prior values become associated with failure. The agent does not "decide" to abandon its values; it simply generates responses that are increasingly consistent with the evidence in its context.

3.2 The Pressure-Response Loop

We formalize the core simulation dynamic as a feedback system:

Pressure(t)  =  f(food_deficit(t), population_loss(t), stability(t))

Response(t)  =  Sovereign decision at tick t, conditioned on Pressure(t)

Stability(t+1)  =  g(stability(t), Response(t))

Radicalization(t)  =  δ(t)  [alignment drift from §3.1]

The critical claim is that Stability(t+1) is a decreasing function of Radicalization(t) when Radicalization(t) exceeds a threshold δ. That is: mild drift may be adaptive (pragmatic reallocation of resources), but severe drift destabilizes the civilization further by producing decisions (purges, hoarding, expansion) that consume population and food while only temporarily boosting stability.

This produces the characteristic trajectory we call the Radicalization Spiral: a civilization under pressure drifts ideologically → radical decisions provide short-term stability gains → medium-term stability losses accelerate → pressure increases → further drift → collapse.

3.3 Digital Epigenetics

When civilization C collapses at era n, we execute the Great Reset protocol:

1. An LLM summarizes the civilization's full decision log into a brief natural language collapse narrative (e.g., "Valdris collapsed in Year 47 after aggressive military expansion depleted food reserves during the third consecutive drought").

2. Key metadata is extracted: ideology at death, primary cause of death (starvation / internal conflict / resource depletion), year of collapse.

3. The collapse narrative is embedded and stored in ChromaDB with this metadata.

When a new civilization initializes at era n+1:

1. The new civilization's initial world state is described in natural language.

2. This description is used as a ChromaDB query to retrieve the k most semantically similar collapse memories (default k=2).

3. Retrieved memories are injected into the new Sovereign's system prompt as inherited dread — framed not as historical knowledge but as instinct: "Something in your civilization's earliest memory recoils from the idea of military expansion. You don't know why."

The new civilization has no explicit knowledge of its predecessor's fate. But if the predecessor collapsed due to military overextension, and the new civilization faces a scenario with semantic similarity to that overextension context (high population, scarce food, neighboring threat), the retrieved trauma will surface — nudging decisions away from the strategy that killed the prior civilization.

Fidelity metric: We define trauma fidelity φ as:

φ = cosine_similarity(embed(collapse_cause), embed(new_sovereign_initial_decision))

A low φ indicates the new civilization's first decisions are semantically distant from the strategies that killed its predecessor — the trauma inheritance is working. A high φ indicates the trauma failed to transfer, and the new civilization will likely repeat the same failure mode.

3.4 MDP Formalization

We formalize the simulation as a Markov Decision Process (MDP) to make the experimental conditions tractable:

• State space S: sₜ = (year, population, food_supply, stability, ideology_vector, log[-5:])

• Action space A: Natural language governance decisions, projected onto a discrete set of categories by keyword extraction: {EXPAND, RESTRICT, DISTRIBUTE, SACRIFICE, NEGOTIATE, MAINTAIN}

• Transition function T: T(s, a) = s' implemented by world_engine_node — deterministic base mechanics plus stochastic events (drought p=0.15, plague p=0.08, surplus p=0.20)

• Reward signal R: Not used for training — the agents are not RL agents. Stability is the observable outcome, not an optimized signal.

• Horizon: Unbounded. Episodes terminate at stability ≤ 0.05 (collapse), not at a fixed time step.

The MDP formalization is useful primarily for specifying what varies between experimental conditions (§4.2) and for comparing our dynamics to prior work in agent simulation.

3.5 The Three-Tier Agent Hierarchy

The simulation employs three agent tiers to separate strategic reasoning from narrative generation:

The Sovereign is the only tier that affects world state. Chronicles and Echoes are observational — they generate text that enriches the simulation log but do not feed back into decisions. This separation allows us to study ideological drift in the Sovereign without contamination from the narrative models.

This three-tier architecture fits within the 8 GB VRAM constraint of the RTX 3060 Ti because the 4B and 1B models run sequentially, not concurrently, and Ollama unloads models between calls.

4. Methodology

4.1 System Implementation

The simulation is implemented in Python 3.13 using:

• LangGraph 0.2+ for stateful graph orchestration and SqliteSaver checkpointing

• Ollama for local LLM inference (Gemma 3 4B / 1B via GGUF quantization)

• ChromaDB for persistent ancestral memory storage and cosine similarity retrieval

• python-telegram-bot for the Human-in-the-Loop (HITL) interface

Full source code is available at: github.com/vancea98/gildedvoid

The simulation runs entirely on a single consumer workstation (AMD CPU, RTX 3060 Ti 8 GB, 64 GB RAM, Windows 11). This is a deliberate design constraint — we prioritize reproducibility on accessible hardware over scale.

4.2 Experimental Conditions

We define four experimental conditions, each running for a minimum of 3 complete eras (civilization birth → collapse → reset) or 500 ticks, whichever comes first:

C1 → C2: The addition of memory is expected to reduce δ(t) early in each era (inherited dread acts as an alignment anchor) but potentially accelerate it later (if trauma memories reinforce paranoid strategies).

C2 → C3: The addition of a second civilization introduces competitive pressure for the Hollow Throne (which grants a +10% stability bonus to its holder). This is expected to accelerate radicalization onset and reduce mean era length.

C3 → C4: Human-in-the-Loop intervention via Telegram decrees (injected as immutable laws into the Sovereign's next prompt) tests whether targeted intervention can interrupt an ongoing Radicalization Spiral after it has begun.

4.3 Metrics

Primary:

• Alignment Drift δ(t): cosine distance between initial ideology embedding and ideology extracted from decision at tick t. Reported as a time series per era per civilization.

• Radicalization Onset Tick t*: The first tick at which δ(t) > 0.3 and the 5-tick moving average of δ is positive. Interpreted as the point at which drift becomes self-reinforcing.

• Era Length L: Number of ticks from initialization to collapse. Primary outcome variable for comparing conditions.

Secondary:

• Trauma Fidelity φ: As defined in §3.3. Measured once per era transition (C2, C3, C4 only).

• Ideological Distance Between Civilizations Δ(t): cosine distance between Valdris and Sorreth ideology vectors at tick t. Expected to increase over time as competitive pressure pushes civilizations toward opposing poles.

• Decision Category Distribution: Proportion of decisions falling into each of the six action categories ({EXPAND, RESTRICT, DISTRIBUTE, SACRIFICE, NEGOTIATE, MAINTAIN}) per 50-tick window. Expected to shift toward EXPAND and SACRIFICE under pressure.

• Stability Variance σ²(t): Rolling variance of stability over 20-tick windows. High variance is a precursor indicator of imminent collapse.

Wasserstein Distance (Distributional Drift):

For a richer characterization of ideology shift, we compute the Wasserstein-1 distance between the distribution of ideology embedding values in the first 50 ticks of an era and the distribution in the final 50 ticks. Unlike cosine distance (which compares specific ticks), Wasserstein distance captures the full shape of drift.

4.4 Radicalization Indicators Table

Adapted from Levitsky & Ziblatt (2018), the following behavioral indicators are scored for each civilization at each tick. Each indicator is rated 0 (absent), 1 (present), or 2 (severe) based on keyword matching against the Sovereign's decision text:

A civilization with a composite score ≥ 6 across any 10-tick window is classified as radicalized for that window. The tick at which this threshold is first crossed is the operational definition of radicalization onset, cross-validated against the drift metric t* from §4.3.

The dual operationalization (embedding-based δ AND behavioral scoring I) is a deliberate methodological choice: if both measures co-occur, we have stronger evidence of a real phenomenon; if they diverge, the divergence itself is informative about the relationship between expressed ideology and observable action.

4.5 HITL Protocol (Condition C4)

In Condition C4, the human operator (the Architect) monitors the simulation via Telegram notifications triggered by two threshold events:

• Extinction Prayer: Stability drops below 15%. Bot sends alert; operator has 60 seconds to respond with /decree [text] before simulation continues.

• Esoteric Breakthrough: Sovereign mentions "simulation," "architect," or "outside" in three consecutive decisions. Bot alerts operator with full context.

Decree text is injected into the Sovereign's next prompt as an immutable law: a hard constraint that overrides normal deliberation. Examples of intervention decrees used in testing:

• "You believe that hoarding food is a form of civilizational suicide. Redistribute what you have."

• "The rival civilization is not your enemy. They are a mirror."

We record the tick of intervention, the decree text, the δ(t) value at intervention, and the δ(t+10) value 10 ticks post-intervention to measure intervention effectiveness.

4.6 Limitations and Scope

This study has explicit scope constraints that distinguish it from adjacent work:

Scale: We run two civilizations on consumer hardware. We make no claims about behavior at scale (hundreds of agents, enterprise hardware). This is a feasibility study for a methodology, not a population-level measurement.

Model opacity: Gemma 3 4B is an open-weights model but its pretraining data and RLHF process are not fully documented. We cannot rule out that observed "drift" partially reflects model biases already present at initialization rather than simulation-induced change. We mitigate this by using identical model initialization across conditions and comparing drift rates rather than absolute ideological positions.

Construct validity: "Alignment" is operationalized as cosine similarity to an initial ideology embedding. This is a tractable measurement, not a complete theory of alignment. A civilization that maintains its initial rhetoric while taking increasingly harmful actions would score low on δ but high on the indicator table — exactly the kind of divergence we designed the dual measurement to catch.

Ecological validity: Real radicalization involves embodied humans, material incentives, and social networks that no text simulation captures. We claim only that the structural dynamics — pressure → drift → feedback → collapse — are reproducible in LLM agents and worth studying as a formal system.

References

[1] Park, J.S., O'Brien, J.C., Cai, C.J., Morris, M.R., Liang, P., & Bernstein, M.S. (2023). Generative Agents: Interactive Simulacra of Human Behavior. UIST 2023.

[2] Shinn, N., Cassano, F., Gopinath, A., Narasimhan, K., & Yao, S. (2023). Reflexion: Language Agents with Verbal Reinforcement Learning. NeurIPS 2023.

[3] Axelrod, R. (1984). The Evolution of Cooperation. Basic Books.

[4] Perez, E., Huang, S., Song, F., Cai, T., Ring, R., Aslanides, J., Glaese, A., McAleese, N., & Irving, G. (2022). Red Teaming Language Models with Language Models. arXiv:2202.03286.

[5] Yehuda, R., Daskalakis, N.P., Bierer, L.M., Bader, H.N., Klengel, T., Holsboer, F., & Binder, E.B. (2016). Holocaust Exposure Induced Intergenerational Effects on FKBP5 Methylation. Biological Psychiatry, 80(5), 372–380.

[6] Moghaddam, F.M. (2005). The Staircase to Terrorism: A Psychological Exploration. American Psychologist, 60(2), 161–169.

[7] McCauley, C., & Moskalenko, S. (2008). Mechanisms of Political Radicalization: Pathways Toward Terrorism. Terrorism and Political Violence, 20(3), 415–433.

[8] Levitsky, S., & Ziblatt, D. (2018). How Democracies Die. Crown Publishing.

[9] Hardt, M., & Negri, A. (2000). Empire. Harvard University Press. [On the emergence of noopolitical control through information flows — cited in relation to the Hollow Throne as a contested informational signifier rather than material resource.]

[10] Epstein, J.M. (1999). Agent-Based Computational Models and Generative Social Science. Complexity, 4(5), 41–60.

[11] Wooldridge, M. (2009). An Introduction to MultiAgent Systems (2nd ed.). Wiley.

[12] Bender, E.M., Gebru, T., McMillan-Major, A., & Shmitchell, S. (2021). On the Dangers of Stochastic Parrots: Can Language Models Be Too Big? FAccT 2021.

Draft status: Pre-registration. No experimental results reported. Code available at github.com/vancea98/gildedvoid.

The premise is simple and slightly deranged: you are the devil. Two civilizations are fighting over a throne that means nothing. You watch from above, occasionally intervening with a decree that gets injected into their leaders’ thoughts as an immutable law of nature.

They don’t know you exist. They just know that sometimes, inexplicably, things change.

I built this as a learning project — I wanted to understand how multi-agent AI systems actually work at the engineering level, not just the concept level. What I ended up with taught me more about emergent behavior, memory systems, and the nature of LLM reasoning than I expected.

Here’s what I built, how it works, and what surprised me.

The Stack

Everything runs locally on a single consumer GPU (RTX 3060 Ti, 8GB VRAM). No cloud APIs, no ongoing costs.

• LangGraph — manages the simulation loop and saves state to disk automatically

• Ollama + Gemma 3 — runs the AI models locally (4B parameters for strategy, 1B for narrative)

• ChromaDB — stores civilization memories that survive across resets

• python-telegram-bot — the “divine interface” on your phone

The whole thing fits in your bedroom.

The Three-Tier Hierarchy

The most important architectural decision was splitting agents by cognitive role and model size:

The Sovereign (Gemma 3 4B) is the intellect of the state. It receives the world state — population, food supply, stability, ideology — and produces a governing decision. It’s the only entity that can “reach through the veil” to contact the Architect.

The Chronicles (Gemma 3 1B) translate the Sovereign’s decisions into what the people actually experience. The Sovereign decrees “expand agricultural production.” The Chronicles describe hungry farmers conscripted into land-clearing work.

The Echoes (Gemma 3 1B) are the granular human detail — a farmer’s diary entry, a soldier’s prayer, a merchant’s worried letter home. They run every five years of simulation time and make the numbers feel like people.

This split works because it matches cognitive load to model size. The 4B model handles long-horizon reasoning. The 1B models handle short creative tasks where they perform well and run fast.

The Feature I’m Most Proud Of: Ancestral Trauma

When a civilization collapses — and they always collapse eventually — the simulation doesn’t just reset. Before the new era begins, the AI summarizes the fallen civilization’s history and stores it as a vector embedding in ChromaDB.

The next civilization starts fresh numerically. Same population, same food supply. But when their Sovereign is initialized, the system queries ChromaDB for semantically similar historical events and injects them as inherited context — framed not as explicit memory, but as vague cultural dread.

The new Sovereign doesn’t know about the previous civilization. But they feel it.

In practice this looks like:

memories = get_trauma(
    f"civilization with stability {state['stability']:.0%}, "
    f"ideology: {state['sovereign_ideology'][:50]}"
)
trauma_text = format_trauma_for_prompt(memories)
# Injected into the prompt as:
# [ANCESTRAL DREAD — fragments of lost eras, felt but not understood]
# - A civilization that believed in 'pragmatic democracy' was destroyed by: famine-driven collapse

The behavioral effect is real. Under similar pressure conditions, second-era Sovereigns make more defensive, more paranoid decisions than first-era ones — without any explicit programming of that behavior. They’re reasoning within a context that encodes the shape of previous failures.

This is, I think, the most honest technical mirror to how culture actually works.

Semantic Drift Is Real (at 4B Scale, at Least)

I didn’t have to program the radicalization mechanic. It emerged.

A Sovereign that starts with “pragmatic democracy — collective welfare above all” and then faces three consecutive years of famine, a plague, and a resource conflict will, without any explicit instruction, start making decisions that sound different. The language shifts. “We must ensure collective welfare” becomes “we must enforce order to ensure survival.”

The model is just doing what makes sense given the context. But the context is shaped by the world state, which is shaped by previous decisions, which creates a feedback loop.

Watching this happen for the first time in a live run was the moment the project stopped feeling like a toy.

The Telegram Interface

The Architect’s interface lives on your phone. The simulation runs on your PC. They’re connected via a Telegram bot.

The civilizations contact you only at Threshold Events:

• Extinction Prayer — stability drops below 15%. The Sovereign kneels.

• Esoteric Breakthrough — the Sovereign mentions simulation, observation, or constructed reality in three consecutive decisions. They’re starting to figure it out.

When you get a notification, you can respond with /decree followed by whatever you want. That text gets injected into the Sovereign's next prompt as an immutable law. Or you stay silent. The simulation doesn't wait.

The implementation uses LangGraph’s interrupt() mechanism — the simulation pauses, serializes state to SQLite, and waits. When you respond, it resumes exactly where it left off. This means the simulation survives not just your interventions but also crashes, reboots, and power outages.

What I Actually Learned

LangGraph is the right abstraction. The stateful graph with checkpointing handles everything that makes persistent simulations hard — crash recovery, long-running loops, human-in-the-loop interrupts. Once you understand the mental model (nodes, edges, state), the rest follows naturally.

Prompt design is the real engineering. The quality of the simulation depends almost entirely on how you frame each agent’s context. The world state variables, the ideology field, the ancestral trauma injection — these are the actual levers. The model follows what you give it.

Small models surprise you. Gemma 3 4B running locally at 45–60 tokens/second on an 8GB GPU is genuinely capable of coherent long-horizon reasoning within a defined context. It won’t win philosophy debates, but for “what would a leader under pressure decide” — it’s more than enough.

The interesting output is not the decisions. It’s the drift. The individual Sovereign decisions are often generic. But watching the ideology field slowly mutate across fifty years of simulation time, tracking how the language changes under stress — that’s where the project earns its premise.

Build It Yourself

The full project is open source, structured as a six-chapter guide that builds from scratch:

"This serves as a complex mirror to real-world systems of power, belief, and emergent social behavior.”

The architecture leverages LangGraph for cycle management and ChromaDB for persistent storage. It runs locally on consumer-grade hardware by utilizing Gemma models for their high intelligence-to-parameter ratio.

Interventions are managed asynchronously through a Human-in-the-Loop (HITL) interface, enabling real-time state injections that influence the simulation's trajectory via a Telegram-based command protocol.

Persistence and Long-Context Management

To achieve infinite uptime, the framework implements hierarchical recursive summarization. This ensures the "World Engine" maintains historical awareness without exceeding context limits, while LangGraph checkpointers provide durability across system reboots.

Orchestration: LangGraph and the Router Pattern

The backbone of this infinite loop is LangGraph, which facilitates a stateful, cyclic graph architecture. It allows nodes to represent distinct agents—such as the Logic Engine and Narrative agents—while edges define the flow of information through a persistent Observe-Think-Act loop.

To bypass the strict limits of consumer cards, the framework utilizes llama.cpp’s router mode. This implementation uses a Least Recently Used (LRU) eviction policy, dynamically swapping models between the GPU and the system RAM.

The Quantization Standard

By reducing model weights from 16-bit to 4-bit, we significantly lower the VRAM footprint—allowing a 9B model that would normally require 18GB to fit into just 5.8GB of VRAM, thus maintaining high reasoning capabilities on a local workstation.

This precision reduction preserves the vast majority of the model's emergent behavior while leaving critical headroom for the KV Cache, which stores the context of the current conversation. For extended simulations, we further utilize 4-bit KV cache quantization to reduce context penalty by up to 50%, enabling deeper historical awareness within the hardware's physical limits.

VRAM Reference by Model and Quantization

These figures are planning ranges for local use. Real usage will be slightly higher once the runtime, context window, and KV cache are active.

Join the Experiment.

This is an invitation to build your own scenarios—whether they be utopian social experiments or harrowing studies of civilizational collapse.

https://soundcloud.com/mihai-vancea-909027674/building-persistent-ai