🚨 TerraGuard — Building an AI-Powered Disaster Simulation System That Learns From You
Most AI projects today stop at one thing:
generate a response → show it → done
But real-world decision-making doesn't work like that.
In disasters, decisions evolve. They cascade. They have consequences. And most importantly — they repeat patterns.
So we asked a simple question:
What if AI didn't just respond… but simulated reality and learned from you over time?
That's how TerraGuard was built.
🧠 The Idea
TerraGuard is an AI-powered disaster simulation system where users make decisions under pressure — and the environment reacts in real time.
But unlike typical simulations:
it's not scripted
it doesn't reset every session
it doesn't forget your mistakes
It evolves with you.
⚙️ How TerraGuard Works
At its core, TerraGuard is a state-driven simulation engine powered by AI.
The loop is simple: AI generates a disaster scenario → User makes a decision → System evaluates impact → Scenario evolves → Repeat for multiple rounds
But the execution is where things get interesting.
🔄 Real-Time AI Simulation (Not Just Chat)
Instead of waiting for full responses, we implemented streaming AI responses.
AI sends output incrementally
Frontend renders it using a typewriter effect
Users experience a live, unfolding situation
This creates:
Lower perceived latency
Higher immersion
Real-time urgency
🎮 Three Modes, Three Realities
We didn't want a one-dimensional experience.
TerraGuard introduces three distinct modes:
👤 Citizen Mode
Personal survival decisions. Small-scale impact. Emotion-driven scenarios.
🚑 Coordinator Mode
Resource management — ambulances, rescue teams. Multiple simultaneous emergencies. Trade-offs and prioritization.
🏛 Official Mode
Large-scale decision-making. Public communication. Budget and inter-agency coordination.
Each mode changes the scale, complexity, and consequences of every decision you make.
🧱 System Architecture
Frontend
React (Vite + TypeScript)
Tailwind CSS
Context + useReducer for state management
The frontend isn't just a UI — it's a real-time simulation controller.
Backend
Node.js + Express
Roles: secure API proxy, streaming handler (SSE), memory integration layer
AI Layer
Google Gemini (primary)
Groq (fallback)
Key decision: enforce structured JSON output to maintain consistency across rounds.
⚡ Streaming with SSE (Server-Sent Events)
One of the hardest parts was implementing streaming correctly.
Instead of: request → wait → response
We built: request → stream → render progressively
Challenges we solved:
Handling partial data mid-stream
Reconstructing valid JSON from chunks
Syncing UI updates without race conditions
Result: A real-time, responsive simulation experience that feels alive.
🧠 The Biggest Upgrade: Memory with Hindsight
Most AI apps are stateless. You close the tab — everything is gone.
That's where TerraGuard becomes fundamentally different.
We integrated a memory layer using Hindsight, built around three phases:
1. Retain (During Simulation)
Stores decisions, outcomes, and context as the session progresses.
2. Recall (Before Each Round)
Fetches past behavior and repeated mistakes, then injects them into the AI prompt — so the scenario adapts to you.
3. Reflect (After Simulation)
Generates behavioral insights and improvement suggestions based on your full history.
The result?
The system can now detect patterns, adapt scenarios, and personalize feedback.
"You tend to delay evacuation decisions — this has cost lives in previous sessions."
That's not a feature. That's behavior modeling.
📊 After-Action Report
At the end of each simulation, TerraGuard generates a detailed report:
Lives saved vs. lost
Performance score and grade
Round-by-round analysis
Critical mistakes
Best decisions
Real-world insights
With memory enabled:
Behavioral profile across sessions
Pattern detection
Improvement recommendations across time
⚠️ Challenges We Faced
1. JSON Reliability
AI doesn't always produce clean, parseable output under streaming conditions.
Solution: Enforce structured output format + add a parsing fallback layer.
2. Streaming Complexity
Handling partial responses without breaking the UI required careful buffering and state management.
3. State Synchronization
Keeping frontend state aligned with AI output across multiple rounds — especially when AI behavior was non-deterministic.
4. Making Memory Meaningful
The hard part wasn't storing logs — it was injecting the right context at the right moment to actually influence AI behavior.
🚀 What We Actually Built
Not a chatbot. Not a game. Not a demo project.
A real-time AI simulation engine with memory-driven behavior adaptation.
🔗 Tech Stack
| Layer | Tech |
|---|---|
| Frontend | React (Vite + TypeScript), Tailwind CSS |
| Backend | Node.js + Express |
| AI | Google Gemini + Groq (fallback) |
| Memory | Hindsight |
| Streaming | Server-Sent Events (SSE) |
💡 Final Thought
AI shouldn't just answer questions.
It should simulate environments, challenge decisions, and help you improve over time.
TerraGuard started as a hackathon idea. It turned into something deeper — a system that doesn't just respond. It reacts, evolves, and remembers.
That shift — from stateless chatbot to stateful simulation engine — is where I think the next wave of genuinely useful AI applications lives.
Built at a hackathon. Open to feedback, collaboration, and questions in the comments.
