CIRCA: City Incident Response & Control Agent

CIRCA uses AI and parallel traffic simulations to test emergency responses before safely applying the best one then learns from the real outcome.

Comment

Inspiration

A crash can turn one blocked lane into a problem several intersections away. We wanted to give traffic operators a way to ask, “What happens if we change the signals, clear a path for an ambulance, or divert cars?” before trying an answer on a live network. That question became CIRCA.

What it does

CIRCA runs a live traffic simulation and shows incidents, vehicles, queues, signals, and emergency responders in an operations console. When an incident appears, it takes a snapshot of the city and tests possible responses in separate SUMO simulations. It rejects unsafe signal plans, then compares the remaining options against doing nothing using delay, queue length, throughput, and EMS response time.

An operator or agent can apply the recommended plan to the live simulation. The tool then watches what actually happens, writes a readable lesson to a Markdown file, and recalls relevant lessons when a similar incident occurs. We also built an adapter for NVIDIA’s VSS Video Analytics MCP incident feed. Our current demo uses simulated camera events; we have not yet tested the adapter against a live NVIDIA endpoint.

How we built it

We used SUMO for the traffic simulation, FastAPI for the backend, and React with MapLibre for the map-first console. The project includes a small downtown grid and a Pittsburgh street layout based on OpenStreetMap, both with synthetic traffic demand.

For each analysis, we restore the same traffic snapshot into fresh SUMO processes so plans get a fair comparison. MCP tools expose the analysis workflow to an agent, while a separate safety validator checks plans before they run. Only a gated implementation step can change the live twin. Afterward, a scorecard compares the prediction with the observed outcome, and the memory system saves the episode as Markdown.

Challenges we ran into

Keeping the live city running while several other versions of it tested different plans was harder than we expected. SUMO’s connection is not thread-safe, and reusing a simulation process could make supposedly identical branches diverge. We had to give the live twin one owner and start each candidate in a fresh process.

Accomplishments that we're proud of

We can inject a collision, watch congestion spread, compare response plans, and see an unsafe timing proposal get rejected before simulation. The autonomous loop has also completed locally with our rule-based agent: it applied a plan, monitored the result, and saved a lesson. On a later run, it recalled that lesson and tested four candidates instead of eight.

What we learned

The useful part of an agent is not simply that it can suggest a plan. It needs a way to test that plan, a safety boundary it cannot bypass, and evidence afterward showing whether its prediction held up. We also found that keeping lessons in readable Markdown makes the system easier to inspect: we can see what it tried, what happened, and why a past decision might matter again.

What's next for Traffic Control Tool

Next, we want to connect the NVIDIA VSS adapter to a running incident feed and qualify the Claude and Nemotron agent paths end to end. We also plan to rehearse the cloud-hosted demo, improve the speed of scenario comparisons, and calibrate the traffic model with real demand and signal data. The bigger goal is to test whether recalled lessons help with different incidents, not just a repeat of the same crash.

Built With

Share this project:

Updates