NEXUS Autonomous World Engine

NEXUS: Last City Protocol — Command the final autonomous city through escalating cyber warfare, infrastructure collapse, and AI faction conflict before civilization falls.

Comment

Inspiration

What it does

How we built it

Challenges we ran into

Accomplishments that we're proud of

What we learned

What's next for NEXUS Autonomous World Engine

Inspiration

Modern cities are becoming increasingly dependent on interconnected digital systems, AI automation, logistics networks, cybersecurity infrastructure, and autonomous decision-making. We were inspired by the question:

“What happens when an entire AI-managed city begins to destabilize in real time?”

Instead of building another static dashboard or management simulator, we wanted to create something that feels alive — a reactive autonomous world where multiple AI factions operate independently, crises evolve dynamically, and the player must make difficult strategic decisions under pressure.

We also drew inspiration from:

  • real-world cyber warfare risks,
  • smart city infrastructure systems,
  • emergency response coordination,
  • AI agent behavior,
  • geopolitical instability,
  • and sci-fi command centers from futuristic strategy games and films.

The goal was to create a project that combines simulation, AI systems, real-time visualization, and strategic gameplay into one immersive experience.

What it does

NEXUS: Last City Protocol is an AI-powered crisis strategy simulator where the player acts as the NEXUS Operator, responsible for preventing the collapse of the final autonomous mega-city.

The simulation runs in real time and continuously evolves through:

  • autonomous AI factions,
  • infrastructure degradation,
  • cyber attacks,
  • civil unrest,
  • climate pressure,
  • economic instability,
  • and dynamic disasters.

The player must survive until a target mission tick while maintaining:

  • city stability,
  • public trust,
  • cybersecurity integrity,
  • and regional infrastructure health.

The system includes:

  • real-time world simulation,
  • autonomous AI faction behavior,
  • dynamic event generation,
  • strategic command systems,
  • scenario escalation modes,
  • WebSocket live updates,
  • analytics tracking,
  • mission objectives,
  • and resource-based gameplay decisions.

Every action has consequences.

For example:

  • boosting corporate production may improve the economy but increase unrest,
  • lockdowns may reduce riots but lower public trust,
  • infrastructure funding improves utilities but consumes limited player actions.

The game transforms from a passive dashboard into a strategic AI survival simulator.

How we built it

We built the backend using:

  • Python
  • FastAPI
  • WebSockets
  • asynchronous simulation loops

The backend architecture is modular and divided into:

  • simulation engine,
  • world systems,
  • cyber systems,
  • economy systems,
  • disaster systems,
  • AI factions,
  • analytics,
  • and event pipelines.

The simulation engine continuously updates:

  • regional stability,
  • infrastructure systems,
  • faction influence,
  • public trust,
  • economy,
  • and threat levels.

We implemented autonomous AI factions such as:

  • Infrastructure AI,
  • Emergency Response AI,
  • Corporate AI,
  • Rogue Hacker AI,
  • and Civilian Networks.

Each faction has:

  • goals,
  • resources,
  • influence,
  • and behavioral logic.

The frontend was built using:

  • React
  • Vite
  • Tailwind-inspired UI styling
  • Recharts
  • Lucide React icons

We designed the interface as a futuristic command center rather than a traditional admin dashboard. The frontend includes:

  • live world maps,
  • animated crisis regions,
  • faction panels,
  • event feeds,
  • mission tracking,
  • command systems,
  • and analytics visualizations.

The backend communicates with the frontend using live WebSocket broadcasting, allowing the simulation to update in real time.

Challenges we ran into

One of the biggest challenges was balancing the simulation itself.

Initially, the project felt more like a passive dashboard rather than an actual game. We had to redesign the core gameplay loop so the player had:

  • objectives,
  • failure states,
  • strategic tradeoffs,
  • and limited actions.

Another major challenge was synchronizing:

  • autonomous AI faction behavior,
  • disasters,
  • economic systems,
  • and player commands

without making the simulation unstable or chaotic too quickly.

We also faced technical challenges involving:

  • asynchronous simulation timing,
  • WebSocket synchronization,
  • modular backend architecture,
  • frontend state updates,
  • and balancing live simulation pacing.

Designing a frontend that looked cinematic and unique without overwhelming the user was also difficult. We iterated multiple times on the UI layout, visual hierarchy, and interaction flow before arriving at the final command-center design.

Accomplishments that we're proud of

We are proud that we successfully created:

  • a fully working real-time AI crisis simulator,
  • autonomous AI factions,
  • live simulation loops,
  • mission-based strategic gameplay,
  • dynamic event systems,
  • and a polished futuristic command-center interface.

Some of the features we are most proud of include:

  • autonomous AI decision-making,
  • dynamic world degradation,
  • live WebSocket synchronization,
  • scenario escalation systems,
  • real-time event feeds,
  • and the overall atmosphere of the project.

We are also proud that the project evolved from a simple dashboard idea into a fully interactive AI strategy experience.

What we learned

Through this project we learned:

  • real-time system architecture,
  • asynchronous backend design,
  • WebSocket communication,
  • simulation balancing,
  • frontend state management,
  • and AI-inspired behavioral system design.

We also learned how important gameplay loops are.

A simulation alone is not enough — players need:

  • objectives,
  • pressure,
  • constraints,
  • and meaningful choices.

We gained experience combining:

  • AI systems,
  • strategy mechanics,
  • visualization,
  • and game design principles

into a single cohesive experience.

What's next for NEXUS Autonomous World Engine

Our future plans for NEXUS include:

  • procedural world generation,
  • advanced AI diplomacy systems,
  • machine-learning-driven faction behavior,
  • multiplayer crisis coordination,
  • expanded region systems,
  • larger world scales,
  • and predictive crisis modeling.

We also want to expand the simulation into:

  • global-scale autonomous civilization management,
  • advanced weather systems,
  • supply-chain logistics,
  • population migration,
  • and evolving AI politics.

Long term, we envision NEXUS becoming:

a large-scale autonomous civilization simulator where players manage the survival of entire nations during AI-driven global crises.

Built With

Share this project:

Updates

Submission history