SurgeSync

Inspiration

Stadium crowd safety is time-sensitive and complex — small incidents can escalate quickly. We were inspired to explore how an autonomous, event-driven multi-agent system combined with telemetry and LLM-driven reasoning could detect anomalies early and coordinate meaningful, timely responses to reduce harm and confusion during large events.

What it does

SurgeSync simulates and coordinates real-time stadium operations: it ingests telemetry, detects anomalies (e.g., crowd surge or crush), reasons over historical/contextual data, and issues recommended actions via an action-executor. The system exposes APIs for monitoring and control and includes a Streamlit dashboard and a mock telemetry publisher for demo/testing. In demo (mock) mode the system can trigger an injected crowd-crush scenario so you can observe end-to-end detection and response.

How we built it

We built SurgeSync in Python 3.11 with a FastAPI backend, MongoDB as a blackboard/state store, and a modular multi-agent architecture. Agents include sensor/ingest agents, historical/context agents, an orchestrator agent that coordinates decisions, and action agents that create execution/log entries. The project contains scripts to spin up MongoDB, run the API, publish mock telemetry, and launch the Streamlit dashboard so the full pipeline can be exercised locally.

Challenges we ran into

Real-time coordination across multiple agents required careful state management and clear interfaces — avoiding race conditions on the blackboard was nontrivial. Designing realistic mock telemetry that triggers meaningful agent behavior took several iterations. Tuning LLM agent prompts and safety checks so recommendations are sensible and not overconfident was also a challenge.

Accomplishments that we're proud of

We created a complete, reproducible demo pipeline: mock telemetry → detection → multi-agent reasoning → action execution → dashboard visualization. The modular agent design and blackboard pattern make it straightforward to add new sensors, caches, or decision agents. The Streamlit dashboard and demo mode let stakeholders quickly experience the system without needing production sensors.

What we learned

Clear, minimal interfaces between agents are essential for reliability; synthetic telemetry is invaluable for testing corner cases; and prompt design plus guardrails matter a lot when LLMs are in the loop. We also learned trade-offs between a centralized blackboard (simple coordination) versus event-driven messaging (scalable concurrency).

What's next for SurgeSync

Integrate real sensor feeds and secure authentication, add richer HITL (human-in-the-loop) workflows and role-based action approvals, and harden the system for production with observability, metrics and CI/CD. We also plan to expand agent capabilities (automated remediation, RL-based policy tuning), and offer Kubernetes deployment manifests and tighter safety/rollback mechanisms for live operations.

Built With

• and
• built-with-python-3.11
• db
• fastapi-+-uvicorn
• gemini-3.1-pro-(vertex-ai)-and-elastic-mcp;-streamlit-+-plotly-for-the-dashboard.-integrates-google-maps
• includes
• mock
• mongodb-(motor)
• openstreetmap/overpass
• openweathermap
• seed
• sportmonks
• telemetry