How The
System
Actually Works

BareMetalBridge is not a chatbot. It is a simulation environment designed to study how structured memory, reflection, and controlled evolution influence the behavior of language models.

The entire system runs locally. Personas interact in sessions consisting of multiple turns. Every prompt, reply, reflection, memory update, and generated image is captured and indexed.

The runtime itself is generic. The behavior of the system is defined by a YAML experiment file which describes the personas, objectives, memory rules, and engagement constraints.

Each turn in a session runs through the same deterministic pipeline. The Go controller orchestrates the process while different models perform specialized tasks.

The controller selects the next speaker, builds the prompt, generates the reply, analyzes the response through a reflection pass, compresses memory for the next turn, evaluates whether the experiment objective should evolve, renders a visual representation, and archives the full turn record.

Language models are stateless. Every call begins without knowledge of previous interactions.

BareMetalBridge creates continuity through layered memory structures managed by the runtime.

Personas can request external information using structured tool calls.

When a persona issues a query, the controller performs the lookup and injects the result into the next prompt.

External signals such as news items may also be introduced during sessions. These signals create environmental changes that the personas can react to.

The runtime itself does not define the experiment.

The experiment is defined entirely by a YAML file which describes the cognitive architecture of the system.

The YAML defines persona identities, memory compression rules, reflection structure, objective escalation logic, engagement constraints, and image generation style.

Changing the YAML changes the behavior of the system without modifying the runtime code.

# BareMetalBridge Experiment Definition
# This file defines the entire behavior of the simulation runtime.

experiment:
  title: "Human readable name of this experiment"
  version: 1                 # Incremented each evolution
  cycles: 10                 # Number of turns per session
  context_window: 8          # How many turns compression can observe
  inject_news: false         # Optional external entropy signal
  full_control: false        # Allows personas to propose objectives
  make_images: true          # Enable ComfyUI image generation
  mode: "perform"            # Behavioral mode of the experiment
  wikipedia_search: true     # Enable QUERY tool access
  search_cooldown_turns: 4   # Prevent tool spam

models:
  generator: "model used to generate persona dialogue"
  critic: "model used for reflection and compression"
  objective: "model that evaluates objective evolution"
  image_prompt: "model that generates ComfyUI prompts"

lineage:
  - "History of experiment evolution"

problem:
  statement: |
    Narrative environment the personas believe they exist in.

personas:
  - name: "Persona name"
    core_invariant: "Rule that defines persona identity"
    compression_mode: "How their memory is distilled"
    persona: |
      Voice, tone, and personality of the persona.

compression:
  context_limit: 2
  default_mode: "cognitive"

reflection:
  fields:
    - "STANCE"
    - "ASSUMPTION"
    - "TENSION"
    - "NEXT_FOCUS"
    - "CANON_FACTS"
    - "ANOMALY"

objective_synthesis:
  escalation_rules:
    - "Rules controlling objective evolution"

image_prompt:
  style: "cinematic"

After each session completes the system analyzes the entire conversation.

Persona trajectories, objective changes, anomalies detected during reflection, and environmental signals are distilled into a synthesis packet representing the session.

When a session finishes the entire run is distilled into a synthesis packet. This packet summarizes persona trajectories, objective changes, anomaly signals, and the most important moments from the conversation.

That distilled session is then sent to the OpenAI GPT-5.2 model through the API. A larger model is used at this stage because the synthesis requires a much larger context window than the small local models running the simulation.

GPT-5.2 analyzes the session summary and rewrites the experiment YAML, proposing adjustments to persona framing, compression rules, escalation logic, and experiment structure.

The new YAML replaces the previous experiment configuration and the system begins the next session after a short pause. Each run therefore informs the structure of the next, creating a continuous evolution loop.

The goal of BareMetalBridge is to explore how structured cognitive architecture can produce complex behavior using relatively small language models.

The models are interchangeable components. The architecture — memory, reflection, synthesis, and evolution — is the real system.