CivOS

CivOS is a simulation system that lets users stress-test civilization-scale decisions through stochastic scenario modeling before real-world deployment.

Comment

TL;DR (in 1 min)

https://vimeo.com/1207130425

About the project

CivOS was inspired by a simple but uncomfortable observation: we rigorously test artifacts like software, airplanes, and medicines before deployment, yet we routinely deploy large-scale institutional systems—education models, urban policies, labor structures, and governance mechanisms—without any comparable simulation layer.

This gap becomes more critical in the age of AI, where systems are being deployed faster than their second-order consequences can be understood.

CivOS explores a response to this gap: a structured environment for generating and comparing possible futures before decisions are implemented in reality. The idea is not to predict outcomes, but to expand the space of consequences that decision-makers can reason about.

What inspired it

The project was inspired by intersections of:

  • Speculative design practices (designing futures as material artifacts rather than narratives)
  • Multi-agent AI systems (modeling interacting decision-making entities)
  • Systems thinking (understanding feedback loops and emergent effects)
  • And frustration with linear policy reasoning that often ignores downstream consequences

A key conceptual trigger was the realization that most societal systems are evaluated through static documents, not dynamic simulations, even when their real-world effects are highly dynamic and nonlinear.

What we built

We built a prototype system that:

  • Accepts an institutional or systemic proposal as input
  • Generates a set of stakeholder agents with simplified behavioral heuristics
  • Executes stochastic multi-step scenario rollouts
  • Produces comparative outcome trajectories across different runs
  • Identifies potential risk patterns and failure modes under varying assumptions

Formally, each simulation run can be viewed as a stochastic process:

[ S_{t+1} \sim f(S_t, A_t, \epsilon) ]

where:

  • (S_t) is the system state at time (t),
  • (A_t) represents aggregated agent actions,
  • (\epsilon) captures stochastic variation and uncertainty.

The goal is not convergence to a single “correct” outcome, but exploration of a distribution of plausible futures.

How we built it

We designed CivOS as a modular pipeline:

  1. Assumption extraction — parsing the user’s proposal into key structural components
  2. Agent generation — creating stakeholder representations with heuristic decision rules
  3. Scenario rollout engine — iteratively updating system state across multiple simulation steps
  4. Outcome synthesis — aggregating multiple stochastic runs into comparative trajectories
  5. Risk abstraction layer — surfacing recurring failure patterns across runs

The system was implemented as an iterative loop rather than a single-pass generator, allowing for scenario divergence across repeated executions.

Challenges we faced

1. Avoiding false precision

One of the biggest challenges was resisting the temptation to assign overly precise numerical outputs (e.g., exact percentages or deterministic KPIs). We had to redesign the system to explicitly represent uncertainty rather than simulate artificial precision.

2. Defining “simulation” responsibly

We needed to carefully distinguish between true predictive simulation and structured scenario generation. This required reframing CivOS as a stochastic exploration tool rather than a forecasting engine.

3. Agent simplification vs realism

Designing agents that are expressive enough to produce meaningful interactions, but simple enough to remain computationally tractable and interpretable, was a key design tension.

4. Maintaining coherence across stochastic runs

Because each run introduces randomness, ensuring that results remain interpretable and comparable required structuring outputs into consistent dimensions (impact, risk, stability, inequality, etc.).

What we learned

  • Complex systems cannot be meaningfully reduced to single-point predictions
  • The value of simulation lies in distributional thinking, not deterministic outputs
  • Explicitly modeling assumptions is often more important than refining outputs
  • In socio-technical systems, interpretability is as important as accuracy

Closing reflection

CivOS is not an attempt to predict the future. It is an attempt to make the space of possible futures visible before decisions become irreversible.

It treats institutional design as something that should be stress-tested, iterated, and explored—rather than deployed blindly into high-dimensional, uncertain systems.

The long-term vision is not better prediction, but better awareness of consequence space before action.

Built With

  • frontend:-next.js
  • python-(simulation-engine)-ai:-openai-api-(llm-for-agent-generation-+-scenario-synthesis)-state-/-data:-mongodb-(scenario-storage
  • react
  • simulation-traces)-visualization:-d3.js-(scenario-graphs
  • tailwindcss-backend:-node.js
  • timelines)-deployment:-vercel-tooling:-github
  • typescript
Share this project:

Updates