WrongWorlds

Your wrong answer becomes a world you must investigate, fracture, rebuild, and escape.

A Museum of Possible Realities for causal reasoning.

The thesis

Most educational AI explains why a learner is wrong. WrongWorlds lets the learner enter a reality where the wrong explanation appears to be true—and escape only after reconstructing the reasoning.

WrongWorlds is a narrative educational game and misconception-reconstruction system. A learner commits to a causal explanation, enters a simulated world governed by that belief, investigates contradictory evidence, rebuilds the explanation, and tests the same reasoning in a new context.

GPT-5.6 interprets learner language. Deterministic engines retain authority over evidence, simulation, state transitions, and scoring.

Experience WrongWorlds in 90 seconds

1. Enter the Portal of Belief.
2. Investigate the three Signal City hotspots.
3. Collect three evidence fragments.
4. Watch the apparent +70 result fracture.
5. Rebuild the causal explanation.
6. Transfer the reasoning in Bloom Station.
7. Reach WORLD ESCAPED.

No account, credentials, or API key are required. The public Judge Mode is a deterministic replay designed to preserve the same evidence, transitions, and result without network variance.

From misconception to transfer

Enter the WrongWorld

The learner's causal belief becomes the governing law of a simulated reality.

Break its false laws

Controlled comparisons reveal evidence the original explanation cannot account for.

Escape with better reasoning

The learner must apply the reconstructed reasoning in a different world.

The educational loop

WrongWorlds is designed around four mechanisms: externalizing a learner's mental model, generating cognitive conflict through evidence, reconstructing the causal explanation, and testing transfer in a new context.

flowchart LR
    A["Learner misconception"] --> B["Belief becomes a world"]
    B --> C["Learner predicts what the world should do"]
    C --> D["Controlled comparisons"]
    D --> E["Contradictory evidence"]
    E --> F["Reality fracture"]
    F --> G["Causal model reconstruction"]
    G --> H["Transfer in a new world"]
    H --> I{"Reasoning transfers?"}
    I -- Yes --> J["WORLD ESCAPED"]
    I -- No --> G

1. Externalization — A misconception becomes inspectable instead of remaining hidden in language.
2. Evidence-driven conflict — The learner experiences a mismatch between the initial explanation and controlled comparisons.
3. Reconstruction — The learner builds a more defensible causal model instead of receiving a correction to memorize.
4. Transfer — Bloom Station checks whether the comparison strategy can be applied outside the original scenario.

This is an educational design hypothesis supported by an exploratory engineering evaluation—not proof of educational efficacy.

GPT-5.6 is an interpreter—not the authority

The optional live path sends free-form English or Spanish learner language through the server-only OpenAI Responses API. GPT-5.6 returns a Structured Output, and the application validates it again with Zod as BeliefModel@2.0.0 before it can enter the experience.

The current contract is derived directly from src/core/ai/schemas.ts:

type BeliefModel = {
  schemaVersion: "2.0.0";
  language: "en" | "es";
  primaryClaim: string;
  claimedCause: "campaign" | "festival" | "district" | "multiple" | "unclear";
  claimedEffect: "sales";
  causalStrength: "certain" | "probable" | "possible" | "unclear";
  mentionedExplanatoryVariables: ("campaign" | "festival" | "district" | "time")[];
  omittedRelevantVariables: ("campaign" | "festival" | "district" | "time")[];
  reasoningPatterns: ReasoningPattern[];
  uncertaintyLanguage: string[];
  conciseMirror: string;
};

causalStrength records linguistic confidence, not evidential validity. claimedEffect is always sales, while explanatory variables are limited to explicitly mentioned campaign, festival, district, or time.

Versioned boundary	Frozen value
Model	gpt-5.6-sol
Belief contract	BeliefModel@2.0.0
Prompt	belief-model.v2.2
Runtime	belief-runtime.v2 — 15 seconds, zero automatic retries
Metrics	belief-metrics.v2.1

Responsibility	GPT-5.6	Deterministic / validated system
Interpret learner language	Yes	No
Produce a structured belief representation	Yes	Validates the contract
Generate experiment outcomes	No	Yes
Decide what evidence was produced	No	Yes
Determine fracture eligibility	No	Yes
Control world state	No	Yes
Evaluate Bloom transfer	No	Yes
Open the exit portal	No	Yes

flowchart LR
    subgraph Modes["Two execution modes"]
      Live["New learner language"] --> Action["interpretBeliefAction"]
      Action --> Interpreter["interpretBelief"]
      Interpreter --> GPT["GPT-5.6 Sol<br/>Structured Output"]
      GPT --> Schema["BeliefModel@2.0.0<br/>Zod validation"]
      Replay["Verified Judge replay"] --> Frozen["getJudgeReplay<br/>frozen interpretations"]
    end

    Schema --> Store["useLearningStore"]
    Frozen --> Store
    Store --> Learning["Learning Engine<br/>transitionLearningSession"]
    Manifest["ScenarioManifest@1.0.0"] --> Simulation["Simulation Engine<br/>pure comparisons"]
    Simulation --> Learning
    Learning --> Evidence["Evidence + fracture eligibility"]
    Evidence --> ChangeMap["ReasoningChangeMap@1.0.0"]
    ChangeMap --> Bloom["BloomTransferSession<br/>pure transfer rubric"]
    Bloom --> Exit{"WORLD ESCAPED?"}

The model may interpret what the learner believes. It cannot change what the evidence means.

Two execution modes, one authority model

Live interpretation path. When explicitly enabled with server-only configuration, GPT-5.6 converts new learner language into the versioned belief contract. Requests use store: false; invalid output or provider failure remains a visible, recoverable error.

Deterministic Judge Mode. The public replay uses exact frozen interpretations from ai-live-20260720T192203945Z-33656. It labels that provenance as a verified replay and does not pretend a live request occurred. The replay exists so every judge can encounter the same evidence and state transitions without credentials.

Both modes feed the same deterministic simulation, learning rules, reconciliation, and transfer rubric. The public release keeps live interpretation disabled with WRONGWORLDS_DISABLE_LIVE=1.

What happens after the learner enters a belief

The runtime sequence below uses implemented functions and state holders—not hypothetical services.

sequenceDiagram
    actor Learner
    participant UI as SignalCityExperience
    participant Store as useLearningStore
    participant Learning as transitionLearningSession
    participant Action as interpretBeliefAction
    participant Interpreter as interpretBelief
    participant GPT as GPT-5.6 Sol
    participant Schema as BeliefModel Zod schema
    participant Simulation as runSignalCityExperiment
    participant Bloom as transitionBloomTransfer

    Learner->>UI: Commit free-form belief
    UI->>Store: dispatch(COMMIT_BELIEF)
    Store->>Learning: apply LearningCommand
    Learning-->>Store: LearningSession at world_lab
    UI->>Action: initial belief request
    Action->>Interpreter: validated request
    Interpreter->>GPT: Responses API, store false
    GPT-->>Interpreter: Structured Output
    Interpreter->>Schema: parse BeliefModel@2.0.0
    Schema-->>Store: receiveInterpretation(initial)
    Learner->>UI: Inspect a Signal City hotspot
    UI->>Simulation: run a named comparison
    Simulation-->>Learning: ScenarioComparison
    Learning-->>Store: evidence log and fracture eligibility
    Learner->>UI: Rebuild explanation
    UI->>Store: receiveInterpretation(revised)
    Store->>Store: reconcileReasoningChange
    Learner->>UI: Test Bloom Station transfer
    UI->>Bloom: controlled comparison and conclusion
    Bloom-->>Learning: successful observable result
    Learning-->>UI: evidence_card / WORLD ESCAPED

In Judge Mode, getJudgeReplay replaces only the live request segment. Every subsequent comparison, transition, reconciliation rule, and transfer requirement is unchanged.

A game state machine—not a sequence of static pages

The five visual acts project real domain state. Presentation state alone cannot advance the learner.

stateDiagram-v2
    [*] --> Threshold
    Threshold --> Believe: startJudgeDemo / COMMIT_BELIEF
    Believe --> Investigate: enterWrongWorld / RECORD before-after
    Investigate --> Investigate: collect one unique experiment
    Investigate --> Fracture: 3 unique fragments + OPEN_FRACTURE
    Fracture --> Rebuild: ACKNOWLEDGE_FRACTURE
    Rebuild --> Transfer: SUBMIT_REBUILD / Judge concepts complete
    Transfer --> Transfer: temporal or missing comparison
    Transfer --> Escaped: successful Bloom rubric + SUBMIT_TRANSFER
    Escaped --> Threshold: Restart

• LearningSession rejects commands issued in the wrong phase.
• A hotspot whose sourceId is already recorded is ignored, so repeated clicks cannot duplicate Judge Mode experiments.
• Fracture requires a one-factor controlled comparison plus a distinct confounder-isolation or population comparison.
• ReasoningChangeMap@1.0.0 marks claims supported only when a recorded comparison isolates that factor.
• BloomTransferSession requires a meaningful hypothesis, isolate-irrigation, a meaningful conclusion, and the required structured concepts.
• WORLD ESCAPED appears only after Bloom reports successful: true and SUBMIT_TRANSFER moves LearningSession to evidence_card.

Signal City: one visible result, multiple causes

The initial before/after view changes campaign, festival, and district together:

Observed change: +70 = +10 campaign + +40 festival + +20 coastal district

The learner initially attributes the whole increase to the campaign. The validated signal-city@1.1.0 manifest instead lets three named comparisons isolate the contributors:

Hotspot	Deterministic experiment	Classification	Evidence purpose
Campaign Transmitter	isolate-campaign	controlled	Isolate the campaign contribution: +10
Festival Stage	isolate-festival	confounder_isolation	Identify the strongest competing contribution: +40
Commercial District	compare-district	population	Compare the coastal district contribution: +20

The educational conclusion is not “the campaign caused nothing.” It is:

The campaign may contribute, but the available before-and-after comparison does not justify attributing the full result—or primary causal responsibility—to it.

Visual gallery

Built to be inspected

WrongWorlds separates product verification, model-interpretation evaluation, and educational evidence so one cannot be mistaken for another.

Evidence layer	Verified status	What it does—and does not—show
Product verification	Final release gate recorded 143/143 Vitest tests, 26/26 active Playwright tests, production build PASS, and 2 offline-profile tests intentionally skipped in that deterministic profile	The code follows its tested contracts; this is not a learning-outcome claim
Public Judge Mode QA	Required routes returned 200; complete replay, zero application POST, zero GPT, mobile, reduced motion, Accessible 2D, and tested axe checks passed	The deployed deterministic path worked at the verified point in time; this is not an uptime or full WCAG claim
Model interpretation	Frozen 20-case holdout processed 20/20; 10 gates passed and 1 failed	Measures structured belief interpretation on a small synthetic holdout, not evidential correctness or learning efficacy
Educational evidence	No learner outcome study completed	Long-term learning and transfer remain unproven and require future study

The visible failed holdout gate is preserved: reasoning-pattern precision / recall / F1 was 0.7857 / 0.7857 / 0.7857, below the pre-registered 0.8500 F1 threshold. Cause acceptable match was 17/18 = 0.9444; explanatory-variable F1 was 0.9630. These values describe model interpretation only.

• Model: gpt-5.6-sol
• Contract: BeliefModel@2.0.0
• Prompt: belief-model.v2.2
• Dataset: belief-benchmark.v2
• Runtime: belief-runtime.v2
• Metrics: belief-metrics.v2.1
• Holdout report: evidence-report.v2.2
• Closeout: evidence-closeout.v1
• Development run: ai-live-20260720T192203945Z-33656
  • Raw SHA-256: c30159f55dfe088a05cfca997f6fda37677a0f21abb54d805b1b6e3da7002e1f
  • Report SHA-256: bde808e88932e5924f1f11134dd4022e3b783798743970743a4862e7ccc22625
• Single authorized holdout: ai-live-20260720T195247731Z-11704
  • Raw SHA-256: d752bb5b10e5893f44ce21be9d2c3ca1fef9f14173f594a24afe79676d30339d
  • Report SHA-256: 8440e6631213d769a142b0cc6e8c6c2c3720a6e6ca5475aad131fa5cd22bd105
• Publication status: exploratory_not_promoted
• Holdout policy: one execution, no post-holdout tuning

The two injection cases passed their bounded checks, but 2/2 synthetic cases are not a general security guarantee. See the public Evidence Archive, frozen final evaluation, and evidence methodology.

The current Evidence Archive is exploratory and is not presented as proof of educational efficacy. Larger learner studies would be required to measure long-term learning and transfer.

The same reasoning experience across interaction modes

The verified experience includes:

• keyboard-operable actions and visible focus treatment;
• English and Spanish paths over the same state;
• prefers-reduced-motion support that preserves the causal revelation;
• an Accessible 2D projection using the same intents and read model as the immersive view;
• tested 390×844 mobile layouts without horizontal overflow;
• semantic radio controls for Bloom Station choices;
• deterministic replay and screen-reader status messages.

Automated Playwright and axe-core checks are part of the gate, but they do not constitute full WCAG certification. Manual screen-reader, forced-colors, 400% zoom, physical-device, Safari, and Firefox review remain outstanding.

Repository map

src/
├── app/                         Next.js routes, server action, and metadata
├── core/
│   ├── ai/                      Belief schemas and deterministic reconciliation
│   ├── learning/                LearningSession state machine and evidence rules
│   ├── simulation/              Pure manifest-driven causal engine
│   ├── transfer/                BloomTransferSession and observable rubric
│   └── evidence/                Evidence Card and manifest projection
├── experience/
│   ├── adapters/                Accessible/immersive parity contract
│   ├── gamefront/               Five-act Judge Mode controller and view model
│   ├── immersive/               React Three Fiber presentation
│   └── state/                   Zustand orchestration
├── integrations/
│   ├── openai/                  Server-only Responses API adapter and prompts
│   └── evidence/                Read-only Archive projection
└── scenarios/
    ├── signal-city/             Causal manifest, experiments, frozen judge replay
    └── bloom-station/           Transfer manifest and comparisons

public/
├── gamefront/v1/                Typed 13-slot illustrated asset set
├── submission/v1/               Deterministic judge-facing screenshots
└── wrongworlds-og.png            Open Graph image

evidence/                         Frozen datasets, raw runs, reports, and closeout
tests/e2e/                        Playwright journeys, accessibility, and public QA
scripts/                          Asset, fixture, and verification tooling
submission/                       Devpost copy, runbook, and media inventory

The dependency direction is intentional: UI and integrations consume typed domain contracts; they do not duplicate simulation equations, fracture rules, or transfer scoring.

Codex as an engineering partner

WrongWorlds was built through a human-directed engineering workflow. Human product direction defined the thesis, educational experience, visual standard, causal correction, evidence policy, and release decisions. Codex accelerated implementation, verification, and reproducibility.

That collaboration covered architecture exploration, typed domain contracts, deterministic engines, automated tests, accessibility, illustrated asset integration, alpha-edge cleanup tooling, screenshot reproducibility, GitHub branching, Vercel Preview and Production QA, and evidence-freeze protection.

GPT-5.6 served the bounded language-interpreter role and was evaluated through versioned evidence artifacts. Neither GPT-5.6 nor Codex was allowed to rewrite causal truth, frozen metrics, or release authority.

The hackathon form still requires a human to run /feedback in the Codex session where most core work occurred and copy the resulting Session ID. Current placeholder: CODEX_SESSION_ID_PENDING_HUMAN_CAPTURE.

Limitations and next exhibits

The current release contains one primary causal-reasoning exhibit, Signal City, and one transfer context, Bloom Station. State remains local and in memory; refresh resets a run. Production deliberately disables live interpretation, while the optional own-belief path requires an explicitly configured server-only GPT connection.

The interpretation evaluation is exploratory, the holdout is small and synthetic, one pre-registered quality gate failed, and no learner study has demonstrated educational efficacy, durable conceptual change, or long-term transfer. Authentication, persistence, telemetry, production privacy workflows, PWA installation, public REST, embed, and MCP deployment are not implemented.

Future exhibits could apply the same misconception → evidence → reconstruction → transfer structure to mathematics, science, economics, history, statistics, systems thinking, and media literacy. Those are directions, not shipped capabilities.

Run locally

Requirements: Node.js 24+ and npm 11+.

Fastest path

npm install
npm run dev

Open the development URL printed by Next.js. Add /?mode=judge for the curated replay or /evidence for the read-only archive.

Deterministic/offline profile

The curated replay needs no OpenAI credentials. For a release-like local environment, explicitly disable live interpretation:

$env:WRONGWORLDS_DISABLE_LIVE='1'
npm run dev

WRONGWORLDS_DISABLE_LIVE=1 npm run dev

Copy .env.example only when local environment configuration is needed. The optional live path requires server-only OPENAI_API_KEY and OPENAI_MODEL=gpt-5.6-sol, plus an explicit decision to remove the live-disable guard. Never expose the key through NEXT_PUBLIC_* variables.

Verification

npm run lint
npm run typecheck
npm test
npm run build
npm run test:e2e
npm run submission:verify
npm run evidence:verify

Run the complete deterministic gate with:

npm run verify

npm run evidence:verify works offline: it validates schemas and frozen hashes, regenerates reports in memory, replays deterministic sessions, verifies Archive references, and scans public artifacts for credential-like values. Do not run benchmark:ai, a holdout, or any live evidence command without explicit authorization.

Judge and engineering documents

• JUDGES_START_HERE.md — shortest verified product path.
• docs/DEMO_RUNBOOK.md — presenter and recovery procedure.
• docs/DEPLOYMENT_VERIFICATION.md — deployed environment and public QA record.
• docs/AI_ROLE.md and docs/PROMPT_CONTRACTS.md — AI authority and versioned contracts.
• submission/DEVPOST_SUBMISSION.md — prepared submission copy.
• submission/VIDEO_SCRIPT.md and shot list — final video plan.
• submission/ASSET_INDEX.md — canonical media inventory.
• PRODUCT_CONSTITUTION.md, SCOPE_LOCK.md, ARCHITECTURE.md, and LIMITATIONS.md — binding boundaries and non-claims.

Final links

Don't tell learners why they are wrong. Let them enter the WrongWorld—and learn how to escape it.