<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: 4Um4 LegoGo</title>
    <description>The latest articles on DEV Community by 4Um4 LegoGo (@4um4).</description>
    <link>https://dev.to/4um4</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F4210190%2F43d661e4-41ed-4296-b3b0-237dac0a4457.png</url>
      <title>DEV Community: 4Um4 LegoGo</title>
      <link>https://dev.to/4um4</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/4um4"/>
    <language>en</language>
    <item>
      <title>Your AI NPC Is Lying to You. It's Not the Model — It's Your Architecture</title>
      <dc:creator>4Um4 LegoGo</dc:creator>
      <pubDate>Wed, 11 Nov 2026 15:42:59 +0000</pubDate>
      <link>https://dev.to/4um4/your-ai-npc-is-lying-to-you-its-not-the-model-its-your-architecture-138e</link>
      <guid>https://dev.to/4um4/your-ai-npc-is-lying-to-you-its-not-the-model-its-your-architecture-138e</guid>
      <description>&lt;p&gt;Everyone blames the model when an AI character contradicts its own past.&lt;/p&gt;

&lt;p&gt;The model hallucinated. The prompt was too weak. We need a bigger context window. Maybe RAG will fix it.&lt;/p&gt;

&lt;p&gt;But what if the actual problem is somewhere else?&lt;/p&gt;

&lt;p&gt;While building &lt;strong&gt;ENIGMA&lt;/strong&gt;, a deterministic causal simulation engine for RPG worlds, I kept returning to a different question:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What prevents something an NPC merely heard from becoming something that actually happened in the world?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;That question led me to an architectural principle that is easy to state and surprisingly difficult to enforce:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;World truth, perception, memory, and belief are different things. They must never be treated as interchangeable.&lt;/strong&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  The dangerous shortcut: treating generated text as memory
&lt;/h2&gt;

&lt;p&gt;Consider a familiar implementation:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="n"&gt;messages&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;append&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="s2"&gt;"role"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"system"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="s2"&gt;"content"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;f&lt;/span&gt;&lt;span class="s2"&gt;"You are Marta. Your life so far: {summary}"&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="n"&gt;reply&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;llm&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;chat&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;messages&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The summarizer reconstructs Marta's past from previous conversations.&lt;/p&gt;

&lt;p&gt;Suppose it invents a detail: Marta's brother died.&lt;/p&gt;

&lt;p&gt;The summary is saved. Later, another conversation uses that summary as context. Marta now mourns a brother who is actually alive.&lt;/p&gt;

&lt;p&gt;The next summary preserves the mistake.&lt;/p&gt;

&lt;p&gt;The model didn't need to be consistently wrong. The architecture made its first mistake persistent.&lt;/p&gt;

&lt;p&gt;This is the distinction that matters:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;A model can generate an incorrect statement.&lt;/li&gt;
&lt;li&gt;A character can believe an incorrect statement.&lt;/li&gt;
&lt;li&gt;A character can remember receiving incorrect information.&lt;/li&gt;
&lt;li&gt;None of these events should silently rewrite objective world history.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;An LLM can hallucinate. The architecture decides what happens next.&lt;/p&gt;

&lt;h2&gt;
  
  
  A claim is not a fact
&lt;/h2&gt;

&lt;p&gt;ENIGMA implements a distinction that is particularly important for social simulation.&lt;/p&gt;

&lt;p&gt;Someone saying that an event happened is itself an objective event.&lt;/p&gt;

&lt;p&gt;The content of what they said is a separate proposition.&lt;/p&gt;

&lt;p&gt;And what another character believes about that proposition is yet another object.&lt;/p&gt;

&lt;p&gt;These are represented separately in ENIGMA's epistemic model.&lt;/p&gt;

&lt;p&gt;The relevant data structures are &lt;code&gt;Proposition&lt;/code&gt;, &lt;code&gt;ClaimEvent&lt;/code&gt;, and &lt;code&gt;EpistemicRecord&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;A simplified view of their actual contracts:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="nd"&gt;@dataclass&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;frozen&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="kc"&gt;True&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;Proposition&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="n"&gt;subject_id&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;str&lt;/span&gt;
    &lt;span class="n"&gt;predicate&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Predicate&lt;/span&gt;
    &lt;span class="n"&gt;object_id&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;str&lt;/span&gt;
    &lt;span class="n"&gt;polarity&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;bool&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="kc"&gt;True&lt;/span&gt;


&lt;span class="nd"&gt;@dataclass&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;frozen&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="kc"&gt;True&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;ClaimEvent&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="n"&gt;event_id&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;str&lt;/span&gt;
    &lt;span class="n"&gt;claim_id&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;str&lt;/span&gt;
    &lt;span class="n"&gt;speaker_id&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;str&lt;/span&gt;
    &lt;span class="n"&gt;listener_id&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;str&lt;/span&gt;
    &lt;span class="n"&gt;proposition&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;Proposition&lt;/span&gt;
    &lt;span class="n"&gt;speech_act&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nc"&gt;SpeechAct&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nc"&gt;SpeechAct&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="no"&gt;ASSERT&lt;/span&gt;
    &lt;span class="n"&gt;tick&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;A proposition describes what is being asserted. It does not contain an objective truth value.&lt;/p&gt;

&lt;p&gt;A ClaimEvent records the communication: who said something, to whom, and when.&lt;/p&gt;

&lt;p&gt;The listener's EpistemicRecord stores a different set of information:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Which agent holds the belief.&lt;/li&gt;
&lt;li&gt;Which proposition they believe.&lt;/li&gt;
&lt;li&gt;Their confidence.&lt;/li&gt;
&lt;li&gt;Who supplied the information.&lt;/li&gt;
&lt;li&gt;Which claim introduced it.&lt;/li&gt;
&lt;li&gt;When it was first observed and last updated.&lt;/li&gt;
&lt;li&gt;Whether the information came from direct observation or testimony.&lt;/li&gt;
&lt;li&gt;The original source in a chain of retold information.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Notice the consequence.&lt;/p&gt;

&lt;p&gt;If Goran tells Tornin that someone stole a ring, the engine can record that Tornin received this claim without declaring that the theft actually happened.&lt;/p&gt;

&lt;p&gt;Tornin may believe it. He may distrust Goran. Someone else may contradict him.&lt;/p&gt;

&lt;p&gt;The world does not need to change just because a sentence was spoken.&lt;/p&gt;

&lt;p&gt;This is not a prompt convention. These are separate data structures with separate responsibilities.&lt;/p&gt;

&lt;p&gt;Sources: &lt;a href="https://github.com/4Um4/Enigma/blob/V.0.5.4.6.2_%D0%9B%D0%9B%D0%9C_2/backend/app/domain/epistemology.py" rel="noopener noreferrer"&gt;epistemology.py&lt;/a&gt;, &lt;a href="https://github.com/4Um4/Enigma/blob/V.0.5.4.6.2_%D0%9B%D0%9B%D0%9C_2/backend/app/services/events/claim_event_subscriber.py" rel="noopener noreferrer"&gt;claim_event_subscriber.py&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Belief revision: who told you matters
&lt;/h2&gt;

&lt;p&gt;Storing beliefs is not enough.&lt;/p&gt;

&lt;p&gt;A character needs a mechanism for updating them.&lt;/p&gt;

&lt;p&gt;ENIGMA uses &lt;code&gt;BeliefRevisionEngine&lt;/code&gt; to process claims and produce updated epistemic records.&lt;/p&gt;

&lt;p&gt;The engine delegates source reliability to a separate provider.&lt;/p&gt;

&lt;p&gt;Its current policy distinguishes between repeated information from the same source and independent confirmation.&lt;/p&gt;

&lt;p&gt;For example:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;A new claim establishes an initial confidence based on source reliability.&lt;/li&gt;
&lt;li&gt;Repetition from the same source provides a smaller confidence increase.&lt;/li&gt;
&lt;li&gt;Confirmation from another source provides a larger increase.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The implementation uses a same-source boost of &lt;code&gt;0.2&lt;/code&gt; against the incoming confidence contribution.&lt;/p&gt;

&lt;p&gt;This is deliberately deterministic and does not require an LLM to decide whether the listener should believe someone.&lt;/p&gt;

&lt;p&gt;There is another important detail: the resulting epistemic context is resolved separately before the decision system consumes it.&lt;/p&gt;

&lt;p&gt;&lt;code&gt;EpistemicContextResolver&lt;/code&gt; projects stored records into cognitively relevant information. &lt;code&gt;DecisionHub&lt;/code&gt; receives that context rather than directly treating the entire epistemic store as its decision interface.&lt;/p&gt;

&lt;p&gt;The result is a causal path:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;NPC_SPOKE / COMMUNICATION_CLAIM
              |
              v
      ClaimEventSubscriber
              |
              v
      BeliefRevisionEngine
              |
              v
         EpistemicStore
              |
              v
    EpistemicContextResolver
              |
              v
          DecisionHub
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;This is a foundation for NPCs that act on what they know, rather than on everything the game engine knows.&lt;/p&gt;

&lt;p&gt;An important distinction: ENIGMA also has a separate &lt;code&gt;BeliefCrystallizationEngine&lt;/code&gt;. It transforms aggregated &lt;code&gt;EvidenceOfPersistence&lt;/code&gt; into persistent psychological beliefs. It is not the same mechanism as the claim-based epistemic revision system.&lt;/p&gt;

&lt;p&gt;I consider this separation important because not every kind of belief should be produced by the same process.&lt;/p&gt;

&lt;p&gt;Sources: &lt;a href="https://github.com/4Um4/Enigma/blob/V.0.5.4.6.2_%D0%9B%D0%9B%D0%9C_2/backend/app/services/npc/belief_revision_engine.py" rel="noopener noreferrer"&gt;BeliefRevisionEngine&lt;/a&gt;, &lt;a href="https://github.com/4Um4/Enigma/blob/V.0.5.4.6.2_%D0%9B%D0%9B%D0%9C_2/backend/app/services/npc/epistemic_context_resolver.py" rel="noopener noreferrer"&gt;EpistemicContextResolver&lt;/a&gt;, &lt;a href="https://github.com/4Um4/Enigma/blob/V.0.5.4.6.2_%D0%9B%D0%9B%D0%9C_2/backend/app/services/npc/belief_crystallization_engine.py" rel="noopener noreferrer"&gt;BeliefCrystallizationEngine&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Memory is not a conversation transcript
&lt;/h2&gt;

&lt;p&gt;Another architectural mistake is assuming that everything an NPC has encountered should be stored as one growing dialogue history.&lt;/p&gt;

&lt;p&gt;In ENIGMA, memory has its own lifecycle.&lt;/p&gt;

&lt;p&gt;&lt;code&gt;MemoryManager&lt;/code&gt; coordinates several memory mechanisms, including:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Layered memory.&lt;/li&gt;
&lt;li&gt;Working memory.&lt;/li&gt;
&lt;li&gt;EventMemory.&lt;/li&gt;
&lt;li&gt;Dialogue sessions and consolidation.&lt;/li&gt;
&lt;li&gt;Persistent storage.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Memory processing also has a defined position in the simulation pipeline.&lt;/p&gt;

&lt;p&gt;The documented tick sequence places memory processing before NPC decision-making.&lt;/p&gt;

&lt;p&gt;That matters because a character should not make a decision using information that only becomes available after that decision.&lt;/p&gt;

&lt;p&gt;It also means that memory is not simply a text summary injected into an LLM context window.&lt;/p&gt;

&lt;p&gt;The character's memory is part of the simulation state, with its own processing and persistence mechanisms.&lt;/p&gt;

&lt;p&gt;There is still substantial development work in this area. ENIGMA's memory architecture is an active development track, not a finished universal memory solution.&lt;/p&gt;

&lt;p&gt;Source: &lt;a href="https://github.com/4Um4/Enigma/blob/V.0.5.4.6.2_%D0%9B%D0%9B%D0%9C_2/backend/app/services/memory/memory_manager.py" rel="noopener noreferrer"&gt;MemoryManager&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Architecture should fail loudly
&lt;/h2&gt;

&lt;p&gt;Here is where the design becomes enforceable.&lt;/p&gt;

&lt;p&gt;It is easy to write:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;Only StateApplicator may modify NPCState.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;It is harder to prevent another module from violating that rule.&lt;/p&gt;

&lt;p&gt;ENIGMA implements a caller-based write guard in &lt;code&gt;NPCState.__setattr__&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;Unauthorized writes to guarded fields raise &lt;code&gt;ArchitecturalViolationError&lt;/code&gt; before the assignment is applied.&lt;/p&gt;

&lt;p&gt;For example, beliefs have an explicit write permission boundary.&lt;/p&gt;

&lt;p&gt;The corresponding test attempts a direct assignment:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="k"&gt;with&lt;/span&gt; &lt;span class="n"&gt;pytest&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;raises&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nc"&gt;ArchitecturalViolationError&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="n"&gt;state&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;beliefs&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The test verifies that the exception identifies the protected field and the unauthorized calling module.&lt;/p&gt;

&lt;p&gt;This is more meaningful than a comment in an architecture document: the rule is exercised by executable code.&lt;/p&gt;

&lt;p&gt;There is an important qualification. The allowlist still contains temporary permissions for several legacy modules. This is a concrete enforcement mechanism for guarded writes, not a claim that every mutable object in the entire application is universally protected.&lt;/p&gt;

&lt;p&gt;Source: &lt;a href="https://github.com/4Um4/Enigma/blob/V.0.5.4.6.2_%D0%9B%D0%9B%D0%9C_2/backend/app/models/npc_state.py" rel="noopener noreferrer"&gt;NPCState&lt;/a&gt;, &lt;a href="https://github.com/4Um4/Enigma/blob/V.0.5.4.6.2_%D0%9B%D0%9B%D0%9C_2/backend/tests/test_belief_single_writer.py" rel="noopener noreferrer"&gt;test_belief_single_writer.py&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  The LLM does not belong in the causal decision loop
&lt;/h2&gt;

&lt;p&gt;Another rule in ENIGMA is that the simulation kernel must not depend on LLM generation to determine its causal decisions.&lt;/p&gt;

&lt;p&gt;The project contains an AST-based checker, &lt;code&gt;lint_llm_exile.py&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;It examines five designated kernel modules:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;&lt;code&gt;tick_orchestrator&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;npc_tick_pipeline&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;decision_hub&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;life_engine&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;phases/decision.py&lt;/code&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;It looks for specified generation methods such as &lt;code&gt;invoke&lt;/code&gt;, &lt;code&gt;complete&lt;/code&gt;, &lt;code&gt;chat&lt;/code&gt;, and &lt;code&gt;generate&lt;/code&gt; on recognized LLM-related receivers.&lt;/p&gt;

&lt;p&gt;The intention is straightforward:&lt;/p&gt;

&lt;p&gt;The simulation determines what an NPC decides and what happens in the world.&lt;/p&gt;

&lt;p&gt;The LLM can participate in language-related work, but its generated text is not automatically authorized to mutate canonical simulation state.&lt;/p&gt;

&lt;p&gt;This checker is intentionally scoped. It is not a universal proof that no possible LLM call exists anywhere in the repository.&lt;/p&gt;

&lt;p&gt;The broader architectural contract is that interpretation and state mutation are separated. For example, &lt;code&gt;StateDeltaProposal&lt;/code&gt; explicitly describes a proposal as input to validation, not as a command that can directly mutate NPC state.&lt;/p&gt;

&lt;p&gt;Source: &lt;a href="https://github.com/4Um4/Enigma/blob/V.0.5.4.6.2_%D0%9B%D0%9B%D0%9C_2/scripts/lint_llm_exile.py" rel="noopener noreferrer"&gt;lint_llm_exile.py&lt;/a&gt;, &lt;a href="https://github.com/4Um4/Enigma/blob/V.0.5.4.6.2_%D0%9B%D0%9B%D0%9C_2/backend/app/domain/state_delta_proposal.py" rel="noopener noreferrer"&gt;state_delta_proposal.py&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Randomness is another source of architectural lies
&lt;/h2&gt;

&lt;p&gt;A simulation that cannot reproduce its own random decisions is difficult to debug.&lt;/p&gt;

&lt;p&gt;Consider:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;random&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;random&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;&lt;/span&gt; &lt;span class="mf"&gt;0.4&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The result depends on hidden process-level RNG state and the order in which random calls occur.&lt;/p&gt;

&lt;p&gt;ENIGMA instead uses &lt;code&gt;KernelRNG&lt;/code&gt;.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="n"&gt;rng&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nc"&gt;KernelRNG&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;
    &lt;span class="n"&gt;tick&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="mi"&gt;42&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="n"&gt;npc_id&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s2"&gt;"maid_lusya"&lt;/span&gt;
&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;rng&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;random&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;&lt;/span&gt; &lt;span class="mf"&gt;0.4&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Its seed is derived from:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="n"&gt;seed_raw&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;f&lt;/span&gt;&lt;span class="s2"&gt;"{tick}:{npc_id}:{salt}"&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;encode&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"utf-8"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;seed&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="kt"&gt;int&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;hashlib&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;sha256&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;seed_raw&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;hexdigest&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;16&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The important contract is:&lt;/p&gt;

&lt;p&gt;Same &lt;code&gt;(tick, npc_id, salt)&lt;/code&gt; → same seed → same initial random sequence.&lt;/p&gt;

&lt;p&gt;Different NPC identifiers or salts produce different seeds.&lt;/p&gt;

&lt;p&gt;There are focused tests for repeated sequences, different NPCs, different ticks, invalid inputs, and deterministic selection.&lt;/p&gt;

&lt;p&gt;ENIGMA also has an AST checker that rejects direct &lt;code&gt;random.*&lt;/code&gt; calls in its designated simulation modules. The RNG and wall-clock checks are registered in the project's pre-commit configuration.&lt;/p&gt;

&lt;p&gt;This does not make every conceivable execution path deterministic. It does make a critical source of hidden nondeterminism an explicit architectural concern with executable checks.&lt;/p&gt;

&lt;p&gt;Sources: &lt;a href="https://github.com/4Um4/Enigma/blob/V.0.5.4.6.2_%D0%9B%D0%9B%D0%9C_2/backend/app/services/npc/kernel_rng.py" rel="noopener noreferrer"&gt;KernelRNG&lt;/a&gt;, &lt;a href="https://github.com/4Um4/Enigma/blob/V.0.5.4.6.2_%D0%9B%D0%9B%D0%9C_2/backend/tests/test_kernel_rng.py" rel="noopener noreferrer"&gt;RNG tests&lt;/a&gt;, &lt;a href="https://github.com/4Um4/Enigma/blob/V.0.5.4.6.2_%D0%9B%D0%9B%D0%9C_2/scripts/lint_kernel_rng.py" rel="noopener noreferrer"&gt;RNG linter&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  What is actually finished?
&lt;/h2&gt;

&lt;p&gt;ENIGMA is not a finished RPG.&lt;/p&gt;

&lt;p&gt;It is an engine under active development.&lt;/p&gt;

&lt;p&gt;Its README describes a 12-layer canonical construction and 18 architectural laws. Several development tracks remain active, including memory architecture, belief-to-expectation work, and narrative grounding.&lt;/p&gt;

&lt;p&gt;I don't want to confuse an architectural foundation with a finished simulation.&lt;/p&gt;

&lt;p&gt;What already exists is a set of distinct mechanisms and executable contracts:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Objective events are not equivalent to claims.&lt;/li&gt;
&lt;li&gt;Claims are not equivalent to beliefs.&lt;/li&gt;
&lt;li&gt;Memory and epistemic state have separate representations.&lt;/li&gt;
&lt;li&gt;Belief revision has an explicit policy and source provenance.&lt;/li&gt;
&lt;li&gt;Protected state has runtime write guards.&lt;/li&gt;
&lt;li&gt;Selected kernel modules are checked for forbidden LLM calls.&lt;/li&gt;
&lt;li&gt;Simulation randomness has an explicit deterministic source.&lt;/li&gt;
&lt;li&gt;Architectural checks are part of the development workflow.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The remaining work is substantial. The system is not presented as a solved theory of cognition or a finished autonomous society.&lt;/p&gt;

&lt;p&gt;But the direction is deliberate.&lt;/p&gt;

&lt;h2&gt;
  
  
  The question worth asking about your own AI agents
&lt;/h2&gt;

&lt;p&gt;When an NPC says something false, ask three questions:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Did the world actually change?&lt;/li&gt;
&lt;li&gt;Did the NPC receive information that was false or incomplete?&lt;/li&gt;
&lt;li&gt;Did the NPC form an incorrect belief from that information?&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;These are three different causal situations.&lt;/p&gt;

&lt;p&gt;If your architecture cannot distinguish them, debugging an NPC's behavior becomes an exercise in interpreting generated text.&lt;/p&gt;

&lt;p&gt;If it can distinguish them, you can inspect the chain of events, identify the source of the belief, and determine where the contradiction originated.&lt;/p&gt;

&lt;p&gt;That is the engineering principle behind ENIGMA:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The world has its own truth. Every character has their own access to it. And the difference between the two must be represented in code.&lt;/strong&gt;&lt;/p&gt;




&lt;p&gt;&lt;strong&gt;ENIGMA — Deterministic Causal Simulation Engine&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Source code: &lt;a href="https://github.com/4Um4/Enigma" rel="noopener noreferrer"&gt;https://github.com/4Um4/Enigma&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Architecture overview and interactive presentation: &lt;a href="https://huggingface.co/spaces/Um44/ENIGMA" rel="noopener noreferrer"&gt;https://huggingface.co/spaces/Um44/ENIGMA&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;Research citation: &lt;a href="https://doi.org/10.5281/zenodo.22831764" rel="noopener noreferrer"&gt;https://doi.org/10.5281/zenodo.22831764&lt;/a&gt;
&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The next challenge is not making NPCs sound more human.&lt;/p&gt;

&lt;p&gt;It is making their knowledge, mistakes, decisions, and consequences form a coherent life.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>gamedev</category>
      <category>architecture</category>
      <category>python</category>
    </item>
    <item>
      <title>Building ENIGMA: a deterministic agent simulation, solo, via free-tier LLM access</title>
      <dc:creator>4Um4 LegoGo</dc:creator>
      <pubDate>Tue, 27 Oct 2026 07:43:41 +0000</pubDate>
      <link>https://dev.to/4um4/building-enigma-a-deterministic-agent-simulation-solo-via-free-tier-llm-access-e58</link>
      <guid>https://dev.to/4um4/building-enigma-a-deterministic-agent-simulation-solo-via-free-tier-llm-access-e58</guid>
      <description>&lt;h1&gt;
  
  
  What is ENIGMA
&lt;/h1&gt;

&lt;p&gt;In March 2026 I started building a deterministic causal simulation engine — agents that act on their own incomplete and potentially erroneous models of the world, not on objective truth. The principle is &lt;code&gt;WORLD TRUTH ≠ NPC MEMORY ≠ NPC BELIEF&lt;/code&gt;, enforced at runtime.&lt;/p&gt;

&lt;p&gt;Today, 7.5 months later: &lt;strong&gt;v0.5.4.4.5&lt;/strong&gt;, &lt;strong&gt;729 commits&lt;/strong&gt;, &lt;strong&gt;18 enforced architectural laws&lt;/strong&gt; (§ENIGMA-001..018), &lt;strong&gt;12-layer canonical construction order&lt;/strong&gt;, AGPL-3.0, Zenodo DOI.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Source code:&lt;/strong&gt; &lt;a href="https://github.com/4Um4/Enigma" rel="noopener noreferrer"&gt;GitHub&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Visual overview:&lt;/strong&gt; &lt;a href="https://huggingface.co/spaces/Um44/ENIGMA" rel="noopener noreferrer"&gt;HuggingFace Space&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Archived version:&lt;/strong&gt; &lt;a href="https://doi.org/10.5281/zenodo.22831764" rel="noopener noreferrer"&gt;Zenodo DOI&lt;/a&gt;
&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;This is &lt;strong&gt;not a game&lt;/strong&gt;. A scientific software artifact in active development.&lt;/p&gt;

&lt;p&gt;This is &lt;strong&gt;not a tutorial&lt;/strong&gt;. Architectural documentation for researchers and engineers working on agent systems, epistemic logic, deterministic simulation, or LLM-assisted engineering.&lt;/p&gt;

&lt;p&gt;This is &lt;strong&gt;not a product&lt;/strong&gt;. Solo-maintained research project, no support SLAs, no roadmap commitments to external stakeholders.&lt;/p&gt;




&lt;h1&gt;
  
  
  The workflow that made this possible
&lt;/h1&gt;

&lt;p&gt;I want to share the engineering methodology, because it's the most interesting part and probably the most reproducible.&lt;/p&gt;

&lt;p&gt;I don't use agent swarms. I don't use API access. I use &lt;strong&gt;free-tier web access to multiple models in parallel, three browser windows, and a human-as-router architecture&lt;/strong&gt;:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Window 1: GLM&lt;/strong&gt; as architect (final ADRs and code)&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Window 2: GPT/Claude&lt;/strong&gt; for design pushback and alternatives&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Window 3: Kimi/DeepSeek/Gemini&lt;/strong&gt; for sanity checks and edge cases&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The models argue with each other through me. I synthesize. The final decision goes to GLM as an architect with a strict format contract (original Russian names kept):&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;БЫЛО:       &amp;lt;one line of code to be replaced&amp;gt;
СТАЛО:      &amp;lt;new code&amp;gt;
IPT:        &amp;lt;invariant checked&amp;gt;
КРАСНЫЕ ИНВАРИАНТЫ: N red → M red
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;(Translation: БЫЛО = before, СТАЛО = after, IPT = invariant probe test, КРАСНЫЕ ИНВАРИАНТЫ = red invariants count)&lt;/p&gt;

&lt;p&gt;This is faster than any agent swarm I've tried. Context window optimization is done by me — I extract relevant fragments from 200K+ lines of code, the models never see the full codebase. Latency hides through parallelism (while model A is thinking, I formulate task for model B, review result from model C).&lt;/p&gt;




&lt;h1&gt;
  
  
  Why this matters: model drift is real
&lt;/h1&gt;

&lt;p&gt;I've observed that newer model versions tend to "drift". GLM 5.3 vs 5.2 — 5.3 wants to design inside its own environment, ignoring the working mode protocol. Similar patterns in Claude and GPT between versions.&lt;/p&gt;

&lt;p&gt;The defense is architectural:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Archaeological protocol&lt;/strong&gt; — no code change without grep/PowerShell archaeology first (§13 of the charter)&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;ADR-PRE-FLIGHT checklist&lt;/strong&gt; — before any code, fill: type, affected domains, downstream consumers, resource budget, rollback plan, regression test&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Executable invariants&lt;/strong&gt; — 18 laws raise &lt;code&gt;ArchitecturalViolationError&lt;/code&gt; at runtime when violated&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Format enforcement&lt;/strong&gt; — every change must list the invariant it checks&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The architecture is &lt;strong&gt;model-agnostic&lt;/strong&gt;. If GLM disappears tomorrow, I switch to another model and continue — because my asset is the discipline, not the model.&lt;/p&gt;




&lt;h1&gt;
  
  
  The 12-layer canonical construction order
&lt;/h1&gt;

&lt;p&gt;Each layer must use the causal work of the layer below, never imitate it.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt; 0. Authoring → Compiler          (LLM translates, Python validates)
 1. Identity / History            (past exists as data, not text)
 2. Body → Need                   (states have consequences, not decoration)
 3. Desire → Object → Activity   (NPC wants something, chooses activity)
 4. Decision → Action → Outcome  (CAN ≠ WANT ≠ INTEND ≠ ATTEMPT ≠ SUCCESS)
 5. Perception → Experience → Memory (NPC knows only what it could perceive)
 6. Salience → Consolidation      (memory becomes selective)
 7. Relationships as History      (relationship = consequence of history)
 8. Belief → Expectation → Decision (NPC acts on its picture of the world)
 9. NPC as Interface              (player learns complexity through NPC)
10. Self-Interpretation           (WHAT HAPPENED ≠ HOW EXPLAINS)
11. Appraisal / Prediction        (surprise as measurable prediction error)
12. Deception                     (lie ≠ ignorance ≠ error ≠ withholding)
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;strong&gt;Anti-Bond rule:&lt;/strong&gt; each layer must prove causal work no other layer performs. No parallel truth-stores. No decorative state.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Dialogue ≠ Memory
Memory ≠ Causality
Belief ≠ Decision
Relationship scalar ≠ History
Self-interpretation ≠ Motivation
LLM ≠ Canonical Truth
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;






&lt;h1&gt;
  
  
  Key architectural principles
&lt;/h1&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Epistemic grounding&lt;/strong&gt; — LLM is never a source of canonical truth; Python = causal authority&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Deterministic replay&lt;/strong&gt; — KernelRNG-protocol, no &lt;code&gt;random.*&lt;/code&gt; or wall-clock in simulation layer (§15)&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Causal layering&lt;/strong&gt; — upper layers must use the causal work of lower layers, never imitate&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Anti-Bond&lt;/strong&gt; — no parallel truth-stores, no decorative state&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Belief non-mutation&lt;/strong&gt; — beliefs are lenses (weight modifiers), not genes (scalars); personality drift via interpretation is forbidden (§16)&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Epistemological orthogonality&lt;/strong&gt; — &lt;code&gt;Reality&lt;/code&gt; and &lt;code&gt;Observer Knowledge&lt;/code&gt; are orthogonal axes; consumers receive only epistemic representations (§17)&lt;/li&gt;
&lt;/ul&gt;




&lt;h1&gt;
  
  
  What's open right now
&lt;/h1&gt;

&lt;p&gt;Active fronts:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;BC-2&lt;/strong&gt; (Conclusion → Expectation) — epistemic circuit&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;MOT&lt;/strong&gt; (Motive &amp;amp; Decision Trace) — decision stores "why", not just "what"&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;MEM&lt;/strong&gt; (Memory Architecture) — long-term memory with decay, consolidation, reconstruction&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;NL-01 phase 1&lt;/strong&gt; (Narrative Grounding) — NPC as interface, three control questions&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The canonical vertical proof is the &lt;strong&gt;"Goran? Yes..." memory scenario&lt;/strong&gt; (track MEM §16.5): an NPC reconstructs its individual history with perspective, temporal structure, surviving and lost details, possible errors, and prediction of future behavior — distinct from &lt;code&gt;WORLD TRUTH&lt;/code&gt;, reproducible by the deterministic engine.&lt;/p&gt;




&lt;h1&gt;
  
  
  Why I'm writing this
&lt;/h1&gt;

&lt;p&gt;Mostly to share the methodology. The "human-as-router with three LLM windows" workflow is something I haven't seen documented, and it's been more effective for me than any agent framework.&lt;/p&gt;

&lt;p&gt;If you're doing similar long-context LLM-assisted work, I'd like to hear your patterns. The comments are open.&lt;/p&gt;

&lt;p&gt;The project itself is research-grade — AGPL-3.0, so if you serve it over network, share the source.&lt;/p&gt;




&lt;h1&gt;
  
  
  Links
&lt;/h1&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;GitHub:&lt;/strong&gt; &lt;a href="https://github.com/4Um4/Enigma" rel="noopener noreferrer"&gt;4Um4/Enigma&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;HuggingFace Space:&lt;/strong&gt; &lt;a href="https://huggingface.co/spaces/Um44/ENIGMA" rel="noopener noreferrer"&gt;Um44/ENIGMA&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;DOI:&lt;/strong&gt; &lt;a href="https://doi.org/10.5281/zenodo.22831764" rel="noopener noreferrer"&gt;10.5281/zenodo.22831764&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Architectural Charter:&lt;/strong&gt; &lt;a href="https://github.com/4Um4/Enigma/blob/main/docs/%D0%90%D0%A0%D0%A5%D0%98%D0%A2%D0%95%D0%9A%D0%A2%D0%A3%D0%A0%D0%9D%D0%AB%D0%99_%D0%A3%D0%A1%D0%A2%D0%90%D0%92_ENIGMA.md" rel="noopener noreferrer"&gt;АРХИТЕКТУРНЫЙ_УСТАВ_ENIGMA.md&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Roadmap v4.12:&lt;/strong&gt; &lt;a href="https://github.com/4Um4/Enigma/blob/main/docs/ENIGMA_ROADMAP_v4_12_WPS.md" rel="noopener noreferrer"&gt;ENIGMA_ROADMAP_v4_12_WPS.md&lt;/a&gt;
&lt;/li&gt;
&lt;/ul&gt;




&lt;h1&gt;
  
  
  Citation
&lt;/h1&gt;



&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight bibtex"&gt;&lt;code&gt;&lt;span class="nc"&gt;@software&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="nl"&gt;gritsaenko_2026_enigma&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
  &lt;span class="na"&gt;author&lt;/span&gt;       &lt;span class="p"&gt;=&lt;/span&gt; &lt;span class="s"&gt;{Gritsaenko, M.}&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
  &lt;span class="na"&gt;title&lt;/span&gt;        &lt;span class="p"&gt;=&lt;/span&gt; &lt;span class="s"&gt;{ENIGMA: Executable Epistemic Contracts in Deterministic Agent Simulation}&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
  &lt;span class="na"&gt;version&lt;/span&gt;      &lt;span class="p"&gt;=&lt;/span&gt; &lt;span class="s"&gt;{0.5.4.4.5}&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
  &lt;span class="na"&gt;year&lt;/span&gt;         &lt;span class="p"&gt;=&lt;/span&gt; &lt;span class="s"&gt;{2026}&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
  &lt;span class="na"&gt;url&lt;/span&gt;          &lt;span class="p"&gt;=&lt;/span&gt; &lt;span class="s"&gt;{https://github.com/4Um4/Enigma}&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
  &lt;span class="na"&gt;doi&lt;/span&gt;          &lt;span class="p"&gt;=&lt;/span&gt; &lt;span class="s"&gt;{10.5281/zenodo.22831764}&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
  &lt;span class="na"&gt;license&lt;/span&gt;      &lt;span class="p"&gt;=&lt;/span&gt; &lt;span class="s"&gt;{AGPL-3.0}&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Happy to answer technical questions about the architecture, the deterministic replay protocol, the KernelRNG, the anti-Bond discipline, or the LLM workflow.&lt;/p&gt;

</description>
      <category>llm</category>
      <category>ai</category>
      <category>architecture</category>
      <category>python</category>
    </item>
  </channel>
</rss>
