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.