FROGUE: The Living Incident

A native causal simulation where a crow, custodian, tree, and room interpret one incident differently—then GPT-5.6 lets you reshape the world and replay it. Built fully in a causal engine codex made

Comment

Inspiration

Most simulated characters react to events because a script tells them what animation or line to play. More advanced AI-driven characters can be flexible, but their decisions often become difficult for creators and players to inspect.

Frogue began from a different question: what would an interactive world look like if every action remained grounded in visible causes?

My goal was not to let a language model invent world truth. The goal was to build persistent residents that perceive events through their own identity, embodiment, pressures, responsibilities, and memories—and can explain why the same event meant something different to each of them.

What it does

Frogue is a native C++ causal simulation and authoring engine. It was created with the philosophy that any wasted compute is a bug. It has a complete tooling system all bespoke to the Frogue engine, the engine works on a pulse driven framework, can explain itself (Self awareness) to 99.7% accuracy, can detect windows stalls, and debugs itself as it runs. For this specific slice the tools used were FrogueMesh - A tool that allows for the conversion to and creation of Frogue specific meshes, it allows for authorable surfaces with unique material properties and provides receipts for watchtower to ingest keeping the explain ability high. FrogueEcho: this is the audio authoring side of Frogue, sound is played in a soundwave that pulses out from the source and interacts with the authored environment, the causal nature of Frogue allows for the sound to be muffled, blocked, echoed or pass straight through empty space. If an object is moving at speed this allows for true Doppler effect production. Frogue Script: This is Frogues native, causal language, it is used in all elements of this slice and unifies the complete eco system.

The Build Week submission presents the Mirror Room, a small living-world demonstration containing four materially different residents with basic versions of their overall umwelts:

  • Huginn**, an urban corvid concerned with danger, novelty, and escape;
  • Custodian 03 (Cleaner droid), a maintenance drone that interprets disruption as responsibility and work;
  • A London plane tree, which responds through environmental and embodied pressures;
  • The room itself, treated as an architectural resident with acoustic, reflective, and structural memory.

A harmless resonant prism is introduced first. Each resident perceives the same object, but assigns it different relevance.

A ceramic mug then strikes a mirror. Frogue captures all four residents at the same causal simulation tick, allowing their pressures, reactions, and explanations to be compared without later routine updates overwriting the important first moment.

The room retains structural memory from the incident. A reinforced-mirror counterfactual then recalculates the event in a separate world branch, changing one causal fact while preserving the initiating conditions.

Finally, Author Change accepts a natural-language request through a constrained GPT-5.6 interpretation route. Frogue presents a reviewable proposal, validates the permitted change, resets a clean copy of the world, reruns the same incident, and explains the changed result.

GPT-5.6 understands the creator's intent. Frogue remains responsible for the world's truth.

How we / I built it

Frogue is a native Windows application written in C++20 using Win32, OpenGL, CMake, and a custom runtime architecture.

Its Pulse Kernel schedules ordered runtime work, while Watchtower records health and classifies runtime incidents. The Build Week daemon owns four persistent causal residents containing relevant subsets of perception, active pressures, memory, personality, responsibilities, action evaluation, and environmental state.

Visual embodiment remains separate from causal truth. Resident-specific adapters translate selected actions into Huginn pose changes, custodian movement and tool emphasis, tree-canopy responses, and architectural resonance effects.

Codex accelerated the audit and integration of the existing engine, ownership tracing, persistent biosim (Frogue's Umwwelt system) work, presentation UI, camera repair, deterministic event fixtures, hero-asset residency, guarded authoring, self-testing, documentation, hardening, and portable packaging.

GPT-5.6 is used as a constrained natural-language interpreter. It may classify a creator request into an allowed semantic route, but it cannot execute arbitrary code, directly alter memory, invent hidden numerical values, bypass validation, or replace the causal simulation.

The complete demonstration also includes a deterministic guarded local interpreter, allowing the judging route to work without an API key or network connection.

Challenges

The largest challenge was turning a broad experimental engine into a focused, reliable three-minute demonstration without bypassing its real architecture.

The original biosim was more report-oriented than persistent, so the residents had to become long-lived world entities whose memories and pressures survived across the demonstration.

Another challenge was preserving one shared causal moment. Residents continue to update over time, but the important first reaction to the mirror incident needed to remain comparable. Frogue therefore captures an explicit shared incident snapshot.

The project also needed to distinguish AI interpretation from simulation authority. Natural-language authoring is useful only when the resulting proposal is inspectable, constrained, reversible, and validated by the engine.

Finally, the source and release had to be hardened into a portable Windows package that judges could run and test without rebuilding the project.

Accomplishments that we / I are / am proud of

  • Four persistent residents interpret the same events differently.
  • Architecture functions as a resident rather than merely scenery.
  • Structural stress becomes remembered anticipatory concern.
  • Counterfactual worlds recalculate consequences rather than replaying scripted alternatives.
  • Natural-language authoring changes validated world parameters instead of puppeteering outcomes.
  • The portable release requires no source build, account, or API key.
  • An automated end-to-end test validates asset residency, novelty, memory, the incident, shared snapshot, counterfactual, guarded authoring, changed replay, and clean shutdown. Basically its a very tiny version of the Matrix (V0.0001) where the longer a simulation is live for the more realistic and entropic.

What we / I learned

Explainability works best when it is part of the simulation model rather than text generated after an action has already been chosen.

I also learned that different perspectives do not require separate scripted stories. When identity, embodiment, responsibility, perception, and memory are represented explicitly, meaning can emerge from the same shared event.

Codex was especially valuable for navigating and hardening a large native codebase, while GPT-5.6 was most useful at the boundary between ordinary creator language and constrained engine operations.

What's next

The Mirror Room is a deliberately small vertical slice of a much larger direction.

Future work includes richer resident embodiment, broader world authoring, expanded causal physics and biosimulation, additional counterfactual tools, persistent multi-room environments, and more creator-facing inspection of how memories and pressures evolve. The main system runs a customised Vulkan graphics package that allows for the receipt and causal nature of the system to continue to have a high "sense of self" although for this project I used the OpenGL backend for simplicity and ease of user / judge builds.

The long-term aim is to help developers build living worlds that remain powerful without becoming opaque in a fully tooled ecosystem that can ingest code from other engines and convert that implicitly to a Frogue standard.

Built With

Share this project:

Updates