STATE
Atlas
Persistent, permissioned project state with provenance.
Simulation & predictive-state workspace
See what happens
next.
Aurora uses the current state represented in Atlas to model possible futures, compare interventions, simulate consequences and understand how decisions propagate through systems — before anything is executed.
- Nova
- What should I do?
- Orion
- What should we do?
- Aurora
- What happens if we do it?
Branching futures from one recorded presentIllustration · simulations run server-side in your project
State → futures → action
Atlas knows the state.
Aurora explores the future.
Apex governs the action.
Every Aurora model starts from recorded project state, not from a blank prompt. Every conclusion can flow back into Atlas with provenance, and every chosen action continues through governed execution — Aurora itself never touches your systems.
FUTURES
Aurora
Model, simulate and compare possible futures.
ACTION
Apex
Execute the chosen change under governance.
Scenario comparison
Compare possible choices before execution.
Describe the system and the decision in front of you. Aurora drafts a digital twin from Atlas evidence, simulates each scenario deterministically on the server, and puts the trajectories side by side — final values, peaks and uncertainty bands included.
Compare scenarios in Aurora →Example comparison · your scenarios come from your own project state
Causality, not vibes
Not just what changes.
Why it changes.
Every twin declares its quantities, parameters and assumptions explicitly. Each parameter cites the Atlas evidence it came from — or is labelled an assumption — and the gaps Aurora could not ground are listed, not hidden.
Models begin with an Atlas recall of your project's recorded state, carried into the result as citable evidence rows.
Parameters without evidence are marked as assumptions, so you can see exactly where the model is guessing.
The same model and scenario always produce the same trajectory — simulations are reproducible, not anecdotal.
Missing evidence is reported with the result. A model that could not be grounded tells you so instead of pretending.
Simulation & governed operation
Run the state forward.
Intervene. Compare with baseline.
Replay a scenario through time and watch the system evolve. On operable twins, start a server-signed run, apply a bounded operation — close a bay, stop a vehicle, change a speed — and Aurora re-simulates the branch deterministically, audited before it is applied. The simulation never reaches physical machinery.
Live operable runs require a twin with a declared operable network (twin v2). Aurora tells you when a model supports them.
Run a simulation →Governed action
Aurora proposes.
It never executes.
When a scenario earns your confidence, its findings are saved to project Atlas with full provenance — the run, the operations, the log hash, the engine. From there, Nova and Orion can recall them, Forge can build the twin into the project, and Apex executes changes under its own approvals. Aurora has no path around governance.
Server-recomputed comparisons stored with provenance, never free-text claims.
Twin → ForgeBuild the simulated twin into versioned project files through the governed build.
Execution stays in Apex, bound to the exact project and artifact receipts.
Worlds In development
From charts to walkable worlds.
Aurora is becoming the user-facing home of Eventium's interactive simulation capability: entering a modelled world, watching runs live in 3D, pausing and replaying, and operating the simulation from inside it — with the server remaining the simulation authority and Atlas remaining the state of record.
Today Aurora ships state modelling, scenario comparison, deterministic replay and governed operations. Interactive 3D worlds are in development and will appear here when they are real — not before.
One platform, one project context
Where Aurora sits in Eventium.
Start in Nova or Orion, explore consequences in Aurora, create in Forge, execute in Apex, act externally through Pilot. The same identity, project and permissions follow you across every surface.
NovaWhat should I do?
OrionWhat should we do?
AuroraWhat happens if we do it?
ForgeBuild it.
ApexExecute it.
PilotAct in external systems.
NovaWhat should I do?
OrionWhat should we do?
PilotAct in external systems.Before you act
What happens if you do it?
Open the simulation workspace and find out — from your project's real recorded state.