DEV Community: LeoTheAIDev

AltiVerse: Simulating Alternate Realities for Real-World Decisions

LeoTheAIDev — Sun, 14 Jun 2026 11:24:47 +0000

Github: https://github.com/LeoTheAIDev/Altiverse
What if you could test a major decision before actually making it?

Not with a spreadsheet.
Not with a static forecast.
Not with a few assumptions hidden inside a slide deck.

I mean watching the decision unfold inside multiple simulated worlds.

That is the idea behind AltiVerse.

AltiVerse forks one real-world decision into several alternate realities, then simulates how people, relationships, moods, routines, and environments evolve differently in each one.

For example:

A school bans phones.
A company moves to a 4-day workweek.
A hospital changes nurses from 8-hour to 12-hour shifts.
A city redesigns how students move between classes.
A workplace introduces mandatory office days.

Instead of asking, “What do we think will happen?”, AltiVerse asks:

“What happens if we run the world forward?”

The Core Idea

Most important decisions affect people indirectly.

A phone ban does not just reduce screen time. It changes social behavior, attention, conflict, boredom, anxiety, rule-breaking, teacher workload, and student relationships.

A 4-day workweek does not just compress hours. It changes fatigue, collaboration, family routines, productivity, burnout, and hidden stress.

An 8-hour versus 12-hour hospital shift does not just change scheduling. It affects handoffs, mistakes, morale, patient continuity, sleep, and team dynamics.

The interesting effects are not always immediate.

They emerge.

That is what AltiVerse tries to capture.

How AltiVerse Works

AltiVerse takes a single decision and creates 2–4 alternate realities from it.

Each reality has the same starting world, but a different policy or condition.

For example:

Reality A

School continues with no phone ban.

Reality B

Phones are banned during class.

Reality C

Phones are banned all day.

Reality D

Phones are allowed only in designated areas.

Then AltiVerse runs each reality forward as a living simulation.

Inside each world, up to around 1,000 agents move through rooms, follow routines, form opinions, react to events, and influence each other.

Each agent can have:

Personality traits
Mood
Relationships
Goals
Stress level
Habits
Social groups
Trust in authority
Reaction to the policy

The point is not to perfectly predict the future.

The point is to expose second-order effects that are hard to see when making decisions manually.

Why This Is Different From a Normal Agent Simulation

A lot of agent-based simulations focus on one world.

AltiVerse is built around comparison.

The product is not just “watch agents move around.”

The product is:

“Show me how the same population diverges across alternate timelines.”

That means the user can click on a person and compare their life across realities.

For example:

Maya, age 15

Reality Outcome
No phone ban Distracted in class, socially comfortable
Class-only ban Better grades, moderate frustration
Full-day ban Less distraction, more anxiety during breaks
Designated-area policy Balanced outcome, fewer conflicts

The power comes from seeing how the same agent changes depending on the system around them.

The Main Interface

The UI is designed around side-by-side realities.

Imagine opening AltiVerse and seeing:

Reality A on the left
Reality B on the right
A shared timeline at the bottom
A divergence graph showing when outcomes begin to split
Agents moving through environments
A panel explaining why a divergence happened

You are not just reading a report.

You are watching the decision unfold.

You can pause the simulation, inspect a moment, click an agent, and ask:

Why did this person’s mood drop?
Why did this group become more isolated?
Why did productivity improve here but not there?
What event caused the realities to separate?
Which policy created the best average outcome?
Which policy helped most people but harmed a specific subgroup?

That last question matters.

Averages hide people.

AltiVerse is designed to show both system-level and individual-level consequences.

Example: School Phone Ban

Let’s say a school is considering banning phones.

A normal analysis might look at research, survey students, ask teachers, and maybe run a pilot.

AltiVerse would simulate multiple versions:

No ban
Class-only ban
Full-day ban
Partial ban with phone zones

Each world starts with the same students, teachers, classrooms, friend groups, rules, and schedule.

Then the simulation runs.

Over time, you might see:

Attention improves in stricter-ban worlds.
Rule-breaking increases when enforcement feels unfair.
Some students become more socially connected during breaks.
Others become more anxious without access to their phone.
Teachers spend more or less time enforcing depending on the policy.
Certain friend groups adapt quickly, while others become more conflict-prone.
A full ban produces better focus but creates more disciplinary incidents.
A partial ban gives slightly lower focus gains but better compliance.

The output is not simply:

“Ban phones” or “don’t ban phones.”

It is more like:

“A class-only ban produces most of the attention gains with fewer enforcement problems than a full-day ban. However, students with high social anxiety may need an exception or support mechanism.”

That is a much more useful recommendation.

Technical Architecture

A possible architecture for AltiVerse looks like this:

Frontend
React or Next.js
Canvas/WebGL rendering for the simulated world
Side-by-side reality comparison
Agent inspection panel
Timeline controls
Divergence visualization
Exportable report view
Simulation Engine
Python or TypeScript
Agent-based simulation loop
Policy rules engine
Environment model: rooms, schedules, constraints
Event system
Memory/state per agent
Metrics tracking over time
Agent Layer

Each agent has structured state:

type Agent = {
id: string;
name: string;
personality: {
openness: number;
conscientiousness: number;
extraversion: number;
agreeableness: number;
neuroticism: number;
};
mood: number;
stress: number;
focus: number;
relationships: Record;
goals: string[];
currentLocation: string;
currentActivity: string;
};

Each policy modifies the environment, not just the agent.

For example:

type Policy = {
name: string;
rules: Rule[];
enforcementLevel: number;
affectedLocations: string[];
exceptions?: string[];
};

The simulation loop might look like:

for (const reality of realities) {
for (const tick of timeline) {
applyScheduledEvents(reality, tick);
updateAgentDecisions(reality);
updateRelationships(reality);
updateMoodAndStress(reality);
recordMetrics(reality, tick);
}
}

Then the comparison layer identifies divergence:

function calculateDivergence(worldA, worldB) {
return {
moodDelta: compareMetric(worldA, worldB, "mood"),
stressDelta: compareMetric(worldA, worldB, "stress"),
focusDelta: compareMetric(worldA, worldB, "focus"),
relationshipDelta: compareNetworkChange(worldA, worldB),
keyEvents: detectInflectionPoints(worldA, worldB)
};
}

The most important part is not just simulation.

It is explainable divergence.

The system should answer:

“When did the worlds start becoming meaningfully different, and why?”

Why I Think This Is Useful

A lot of decisions are made using simplified models.

But human systems are messy.

People react to incentives, rules, stress, peer pressure, boredom, and each other. Small changes can create feedback loops. A policy that looks good on paper can fail because people experience it as unfair, confusing, or exhausting.

AltiVerse gives decision-makers a sandbox for exploring those dynamics.

AltiVerse — Fork a decision. Watch the worlds it creates. 🌱

LeoTheAIDev — Sat, 13 Jun 2026 12:26:42 +0000

AltiVerse — Fork a decision. Watch the worlds it creates. 🌱

Every big decision has a hidden second half you never get to see. AltiVerse lets you fork one choice into 2–4 alternate realities and run each forward as a small living world — up to ~1,000 people who move, stress out, bond, clash, spread rumours, and tell you how it felt.

It's a thinking tool for the second-order effects of a decision — a school phone ban, a 4-day week, 8- vs 12-hour hospital shifts — and a hands-on way to learn systems thinking, the scientific method, and agent-based modeling. Best of all: it's local-first, runs fully offline, and needs no account.

▶️ Try it in one line (Node 18+):
npx github:LeoTheAIDev/Altiverse

⭐ GitHub: https://github.com/LeoTheAIDev/Altiverse

— What you can do —
🔱 Fork one decision into 2–4 alternate realities on a shared timeline
🧑‍🤝‍🧑 Watch living worlds of people — friendships, rivalries, rumours, burnout
👤 Click any person to compare how they specifically fare in every timeline
📊 See exactly when & why the worlds diverge (live metrics + divergence chart)
📝 Export a full report with an executive summary and a recommendation
🔒 100% local — runs offline, bring any AI model (Ollama, LM Studio, OpenAI, Groq…) or none

— How it works —
A deterministic engine drives every number (same seed → identical world, every run), so it's a real controlled experiment. An optional AI layer only writes the prose: in-character thoughts, interviews, headlines, and the final report. Turn the model off and everything still works.

— Built with —
Vite · React · TypeScript · a deterministic Mulberry32 simulation engine · any OpenAI-compatible model. No backend. No telemetry. Open source (MIT).

Made for the AI × STEM Education hackathon 🚀

🎵 Music: "The Kill 2" — Lex Amarni, 2muchmotion

AltiVerse #AI #STEMeducation #simulation #agentbasedmodeling #systemsthinking #localfirst #opensource #reactjs #typescript #edtech #hackathon #LLM #ollama

I Built AltiVerse: Fork Decisions Into Living Simulations With 1,000 Personalities

LeoTheAIDev — Sat, 13 Jun 2026 08:02:02 +0000

I Built AltiVerse: Fork Decisions Into Living Simulations With 1,000 Personalities

What if you could see the real consequences of a decision before making it?

Not with abstract models or spreadsheets — but by watching full living simulations unfold.

That’s what AltiVerse is.

GitHub:

LeoTheAIDev / Altiverse

Fork decisions into living simulations with 1,000 personalities. Watch alternate realities diverge and explore second-order effects.

Take one choice. Play it forward as several alternate realities — each a small living world of people who move, stress out, break rules, burn out, form friendships and rivalries, and tell you how it felt.

What is AltiVerse?

AltiVerse forks a single decision — a school phone ban, a 4-day week, 8- vs 12-hour hospital shifts — into 2–4 alternate realities and runs each one forward as a small, living simulation. Up to ~1,000 people with personalities, moods, and relationships move through rooms, react to the policy, and slowly pull the worlds apart. You watch when and why the realities diverge, click any person to compare how they fare across timelines, and export a full report with a recommendation.

It is a thinking tool, not a predictor. Every number and quote comes from a deterministic engine (same seed → same world, every time), with an optional local or online…

View on GitHub

The Idea

AltiVerse lets you take any decision (school phone ban, 4-day work week, hospital shift changes, etc.) and fork it into 2–4 alternate realities.

Each reality runs as a deterministic living simulation with up to 1,000 agents. Every agent has:

Unique personality
Changing moods
Memories
Relationships

They move through rooms, interact, react to the decision, and slowly evolve.

Key Features

Watch the worlds evolve side-by-side
See exactly when and why the timelines diverge
Click any person to compare how their life turns out across all realities
Generate detailed reports with in-character thoughts and insights
Fully deterministic (same seed = same world every time)

Example

I forked a school phone ban into four realities.

In one timeline grades improved but anxiety spiked.

In another students rebelled and social connections collapsed.

The divergence was clear and fascinating.

How It’s Built

Web interface for forking decisions and exploring timelines
Optional LLM layer for natural prose in reports and thoughts

The project is fully open source.

What’s Next

I’m working on better performance, richer personalities, and more visualization tools.

What decision would you want to fork and simulate? Drop your ideas in the comments — happy to run a few and share the results.

Feedback is very welcome, especially on simulation mechanics and UX.

This version keeps it general and focused on the core idea. Add your GIFs/screenshots when publishing.

Want any tweaks?

I Built AltiVerse: Fork Any Decision Into Living Simulations With 1,000 Personalities

LeoTheAIDev — Thu, 11 Jun 2026 21:57:21 +0000

I Built AltiVerse: Fork Any Decision Into Living Simulations With 1,000 Personalities

What if you could see the real human consequences of a decision before making it?

Not through abstract models or spreadsheets — but by watching living simulations of people reacting, interacting, and slowly pulling realities apart.

That's what AltiVerse is.

The Problem

We constantly make decisions with massive second-order effects:

Should we ban phones in schools?
Is a 4-day work week actually better?
Are 8-hour or 12-hour hospital shifts healthier in the long run?

Traditional tools fail here. They can't capture how real humans with emotions, relationships, and memories behave over time.

What AltiVerse Does

AltiVerse lets you:

Pick any decision and fork it into 2–4 alternate realities
Run each as a deterministic living simulation with up to 1,000 agents
Each agent has personalities, moods, memories, and relationships
Watch people move through rooms, talk, form groups, and evolve
See exactly when and why the timelines diverge
Click any person to compare their entire life across realities
Export a full report with in-character thoughts and recommendations

Everything is fully deterministic — same seed = same world every time. Optional LLM layer only for readable prose.

Example: School Phone Ban

I forked a strict phone ban into 4 slightly different implementations.

In one timeline: Academic performance improved significantly
In another: Students became more isolated and anxiety spiked
In a third: Rebellion culture emerged by week 6

The divergence was visible and fascinating.

Technical Highlights

Deterministic simulation engine
Room-based spatial movement and interaction system
Individual agent memory and relationship modeling
Timeline comparison UI
Report generation with optional LLM enhancement

The project is completely open source.

Try It Yourself

LeoTheAIDev / Altiverse

Fork decisions into living simulations with 1,000 personalities. Watch alternate realities diverge and explore second-order effects.

What is AltiVerse?

It is a thinking tool, not a predictor. Every number and quote comes from a deterministic engine (same seed → same world, every time), with an optional local or online…

View on GitHub

Quick start instructions are in the README.

What’s Next?

I’m actively improving:

Performance and scaling (aiming for more agents)
Richer personality and relationship systems
Better visualization tools
More example scenarios