MIRROR//WORLD

An AI counterfactual reasoning engine that explores multiple possible futures from your decisions—revealing trade-offs, risks, assumptions, and uncertainty.

Comment

MIRROR//WORLD

An AI Counterfactual Reasoning Engine

Don't predict the future. Explore it.

Inspiration

We make important decisions every day, but most AI systems approach these decisions in a surprisingly simple way: we ask a question, and the model gives us an answer.

We wanted to explore a different question:

What if AI could help us explore the decision landscape instead of simply telling us what to do?

That idea became MIRROR//WORLD.

MIRROR//WORLD is an AI counterfactual reasoning engine that takes a real-world scenario, identifies its constraints and assumptions, explores multiple possible paths, stress-tests those paths, and presents the resulting trade-offs and uncertainties in an interactive future tree.

It doesn't claim to predict the future.

Instead, it asks:

"What could happen under these assumptions?"

The Problem

A conventional AI interaction often looks like:

Question
   ↓
LLM
   ↓
Answer

This can be useful, but it has a major limitation: a single response can hide assumptions, alternative possibilities, and uncertainty.

For decisions involving multiple variables, simply generating one answer isn't enough.

We wanted to build an AI system that makes the reasoning workflow itself part of the product.

Our Core Insight

The central idea behind MIRROR//WORLD is:

A decision should be explored as a landscape of possible outcomes, not reduced to a single answer.

Instead of using one prompt, MIRROR//WORLD creates a structured workflow:

USER SCENARIO
      ↓
CONTEXT EXTRACTION
      ↓
ASSUMPTION MODEL
      ↓
SCENARIO FORKING
      ↓
┌──────────┬──────────┬──────────┐
│ FUTURE A │ FUTURE B │ FUTURE C │
└──────────┴──────────┴──────────┘
      ↓
CONSEQUENCE ANALYSIS
      ↓
CRITIC / STRESS TEST
      ↓
UNCERTAINTY ANALYSIS
      ↓
SCENARIO COMPARISON
      ↓
FINAL SYNTHESIS

The result is not simply another AI answer. It is an interactive exploration of possible futures.

How MIRROR//WORLD Works

1. Scenario Understanding

The user describes a decision.

For example:

"I have 30 days. Should I spend my evenings preparing for an exam, building an AI project, or split my time between both?"

MIRROR//WORLD extracts the important context:

  • objective
  • available time
  • alternatives
  • constraints
  • time horizon
  • relevant assumptions

This creates a structured representation of the scenario before generating outcomes.

2. Assumption Modeling

The system separates information into:

Known information

What the user explicitly provided.

Assumptions

What the simulation needs to assume.

Unknown variables

Factors that could significantly affect the result.

This distinction is important because a simulated future is only as meaningful as the assumptions behind it.

3. Scenario Forking

Instead of producing one answer, the system generates multiple possible paths.

For example:

                    CURRENT STATE
                          ●
                       /  |  \
                      /   |   \
                     ●    ●    ●
                    /     |     \
                FUTURE A FUTURE B FUTURE C

Each branch represents a different strategy or counterfactual.

The user can select a branch and explore it further.

4. Consequence Analysis

Each branch is analyzed for:

  • potential benefits
  • potential risks
  • dependencies
  • second-order effects
  • important assumptions
  • possible trade-offs

This prevents the system from treating a decision as having only one obvious consequence.

🧠 The Critic Engine

One of the most important parts of MIRROR//WORLD is the Assumption Stress Test.

After generating scenarios, the system asks a separate reasoning stage:

What could make this scenario wrong?

It examines:

  • fragile assumptions
  • ignored variables
  • counterarguments
  • dependencies
  • conditions that could change the outcome

This creates an important distinction between:

"Here is an AI-generated possibility."

and:

"Here is a possibility, and here is why it might fail."

🌫️ Uncertainty

MIRROR//WORLD intentionally does not pretend that simulations are perfect predictions.

Instead, it identifies where uncertainty comes from.

For every scenario, the system distinguishes between:

KNOWN
ASSUMED
UNKNOWN
DEPENDENT

The interface then communicates the uncertainty level and explains its source.

We deliberately avoid fabricated numerical probabilities when there isn't enough evidence to justify them.

The system therefore makes an important distinction:

Simulation ≠ prediction.

MIRROR//WORLD explores possibilities under assumptions; it does not claim to know the future.

🌳 The Future Tree

The main visual interface is the Future Tree.

Instead of presenting the result as a wall of text, possible outcomes become an interactive graph.

Users can:

  • zoom into branches
  • inspect individual scenarios
  • compare paths
  • change assumptions
  • rerun simulations
  • explore counterfactuals

This turns AI reasoning into something that can be explored visually.

🔀 What If Mode

After generating a simulation, users can change an important variable.

For example:

Study time

2 hours/day
      ↓
4 hours/day

Then the user can select:

RE-SIMULATE

The system generates the changed scenario and highlights which branches were affected.

This creates an interactive counterfactual loop:

SIMULATE
   ↓
CHANGE ASSUMPTION
   ↓
RE-SIMULATE
   ↓
COMPARE
   ↓
EXPLORE

⚔️ Workflow vs. Single Prompt

A major part of our project is demonstrating that the architecture itself matters.

MIRROR//WORLD includes a comparison mode:

Single-Prompt Approach

Scenario
   ↓
One AI prompt
   ↓
One response

MIRROR//WORLD

Scenario
   ↓
Context
   ↓
Assumptions
   ↓
Multiple scenarios
   ↓
Consequence analysis
   ↓
Critic
   ↓
Uncertainty
   ↓
Comparison
   ↓
Synthesis

We don't intentionally make the single-prompt system worse.

Instead, we compare the two approaches on the same scenario and examine differences in:

  • scenario diversity
  • assumption visibility
  • risk analysis
  • counterarguments
  • uncertainty
  • final synthesis

This allows us to evaluate whether a structured AI workflow provides meaningful advantages over a conventional single interaction.

⚙️ Technical Architecture

The system is designed as a modular pipeline rather than a single giant prompt.

Conceptually:

                 USER
                  │
                  ▼
        ┌──────────────────┐
        │ Scenario Parser  │
        └────────┬─────────┘
                 │
                 ▼
        ┌──────────────────┐
        │ Context &        │
        │ Assumption Model │
        └────────┬─────────┘
                 │
                 ▼
        ┌──────────────────┐
        │ Scenario Forker  │
        └─────┬────┬───────┘
              │    │
             A     B     C
              │    │     │
              └────┼─────┘
                   ▼
        ┌──────────────────┐
        │ Consequence      │
        │ Analyzer         │
        └────────┬─────────┘
                 ▼
        ┌──────────────────┐
        │ Critic / Stress  │
        │ Test             │
        └────────┬─────────┘
                 ▼
        ┌──────────────────┐
        │ Uncertainty      │
        │ Analyzer         │
        └────────┬─────────┘
                 ▼
        ┌──────────────────┐
        │ Comparator &     │
        │ Synthesizer      │
        └────────┬─────────┘
                 ▼
           FUTURE TREE

The modular architecture makes individual stages replaceable and easier to test.

🤖 AI Workflow

The AI is used for several distinct tasks rather than being treated as a single answer generator.

Context Extraction

Converts natural language into structured scenario information.

Scenario Generation

Creates alternative paths based on the user's options and constraints.

Consequence Analysis

Explores direct and second-order consequences.

Critical Review

Attempts to challenge the generated scenarios.

Uncertainty Analysis

Identifies assumptions and unknown factors.

Synthesis

Combines the outputs into an understandable comparison.

This separation allows us to inspect and improve individual stages instead of treating the entire AI system as a black box.

💻 Example Workflow

A simplified conceptual representation is:

const context = await extractContext(userScenario);

const assumptions = await buildAssumptionModel(
  context
);

const scenarios = await generateScenarios(
  context,
  assumptions
);

const analyzed = await analyzeConsequences(
  scenarios,
  assumptions
);

const critique = await stressTest(
  analyzed
);

const uncertainty = await analyzeUncertainty(
  analyzed,
  critique
);

const result = await synthesize(
  analyzed,
  critique,
  uncertainty
);

The production implementation handles validation, errors, state management, and API communication around these stages.

🧮 Conceptual Model

We can represent a simulated state as:

$$ S_t = [G_t, K_t, H_t, T_t, R_t] $$

where:

  • (G_t) represents goals
  • (K_t) represents relevant knowledge or skills
  • (H_t) represents habits or behavioral factors
  • (T_t) represents available time
  • (R_t) represents available resources

A decision can then be viewed conceptually as a state transition:

$$ S_{t+1} = F(S_t, a_t, \epsilon) $$

where (a_t) is an action and (\epsilon) represents uncertainty.

This is not intended to claim that human futures can be mathematically predicted with certainty. It provides a conceptual framework for thinking about how assumptions and decisions can create different simulated trajectories.

🎨 User Experience

We wanted the interface to feel less like a conventional AI dashboard and more like an interactive laboratory.

The visual language combines:

  • dark cinematic surfaces
  • subtle glassmorphism
  • interactive nodes
  • neural-style connections
  • smooth transitions
  • information-dense but readable panels
  • responsive layouts

The Future Tree is the centerpiece because the visualization itself communicates the core idea:

There isn't necessarily one future. There are possibilities shaped by decisions and assumptions.

🧩 Challenges

Designing a Genuine AI Workflow

Our first challenge was avoiding the temptation to solve everything with one large prompt.

We had to think about which tasks should be separated, what information should flow between stages, and how to make each stage contribute something meaningful.

Avoiding False Precision

Another challenge was communicating uncertainty without inventing scientific-looking numbers.

A visually impressive prediction can still be misleading if its assumptions are hidden.

We therefore designed MIRROR//WORLD around explicit assumptions and uncertainty explanations.

Making Complex Reasoning Understandable

A multi-stage AI pipeline can become confusing for users.

The Future Tree became our solution: instead of exposing complicated internal processing, we turn the results into an interactive visual model.

Building as a Solo Developer

MIRROR//WORLD was developed as a solo project.

That forced us to prioritize the core experience instead of attempting to build an enormous platform immediately.

The focus became:

One idea. One workflow. One unforgettable experience.

📚 What We Learned

Building MIRROR//WORLD taught us that effective AI products aren't necessarily created by simply using a larger model.

The workflow surrounding the model matters.

We learned about:

  • prompt decomposition
  • multi-stage AI workflows
  • structured context
  • counterfactual reasoning
  • uncertainty communication
  • AI evaluation
  • interactive visualization
  • responsible AI product design

Most importantly, we learned to treat AI outputs as hypotheses to examine, rather than unquestionable answers.

🚀 What's Next

MIRROR//WORLD is currently focused on decision exploration, but the architecture can extend far beyond personal decisions.

Potential future applications include:

Education

Explore different learning strategies and their possible consequences.

Startups

Explore strategic choices such as hiring, pricing, product development, and resource allocation.

Urban Planning

Explore possible effects of changes in transportation, infrastructure, or policy assumptions.

Climate & Sustainability

Explore scenarios under different environmental assumptions.

Research

Create interactive environments for exploring complex hypothetical systems.

The long-term vision is to build a general-purpose counterfactual exploration layer for human decision-making.

🌍 Our Vision

AI doesn't have to be a machine that simply tells us what to do.

It can become a tool for exploring possibilities.

MIRROR//WORLD is built around one simple idea:

The future isn't a single answer. It's a landscape of possibilities.

We don't claim to predict what comes next.

We built MIRROR//WORLD to help people explore what could.

Built With

Share this project:

Updates

Submission history