Dispatch

Dispatch's Dashboard Home Page
Dispatch Running Agentic Orchestration Workflow

Inspiration

Emergency response remains one of the most demanding real time coordination environments in the world. During active incidents, dispatchers are responsible for simultaneously processing incoming 911 calls, monitoring radio traffic, updating CAD systems, documenting critical information, coordinating response units, and relaying updates to responders in the field. In rapidly evolving emergencies, even minor communication failures or delayed information can escalate into severe operational consequences. Our inspiration for Dispatch came from real incidents in which communication and dispatch errors contributed to catastrophic outcomes. These scenarios exposed a larger systems-level problem: modern emergency response still relies heavily on a single operator manually coordinating fragmented streams of information under extreme pressure. We wanted to explore what emergency response could look like if dispatch systems were capable of reasoning alongside operators in real time. That idea became Dispatch: an autonomous AI co-dispatch system built to reason, coordinate, and respond alongside emergency operators on NVIDIA edge hardware.

What it does

Dispatch is an autonomous operational AI agent designed to actively assist emergency coordination during rapidly evolving incidents. Instead of functioning as a passive dispatch dashboard, the system autonomously tracks incident progression, escalates critical events, coordinates operational workflows, updates responder context, and triggers real-time tool-based actions as emergencies unfold.

As new information arrives, Dispatch continuously reassesses threat levels, prioritizes critical updates, detects conflicting information, and dynamically coordinates response actions across the system. The agent maintains evolving situational awareness in real time while autonomously executing workflows designed to simulate operational dispatch tasks such as incident escalation, responder coordination, priority reassignment, and emergency status updates.

Running entirely locally on the ASUS GX Spark using NVIDIA Nemotron models and OpenClaw orchestration, Dispatch performs low-latency autonomous reasoning and workflow execution directly on-device without reliance on cloud infrastructure, enabling faster response coordination, operational resilience, and local handling of sensitive emergency communication data.

How we built it

We built Dispatch using NVIDIA Nemotron models running locally on the ASUS GX Spark alongside OpenClaw based orchestration to create a real-time autonomous multi-agent system for emergency response. The architecture is built around an asynchronous event-driven pipeline where specialized agents continuously reason over evolving incident state and communicate through a shared operational event bus.

Incoming 911 communication streams are converted into live transcript events and distributed across multiple reasoning agents operating in parallel. Triage agents continuously reassess incident severity and confidence as new information arrives, location agents extract and verify responder coordinates through tool-based database queries, and supervisory agents monitor operational uncertainty, conflicting information, and escalation thresholds in real time.

Once operational confidence thresholds are met, dispatch agents autonomously trigger tool calling workflows to execute simulated coordination actions such as querying responder availability, escalating incident priority, updating responder status, coordinating EMS deployment, and maintaining continuously evolving operational context. Additional agents continuously generate structured incident reports, timeline updates, and responder summaries as emergencies unfold.

By running entirely on device, Dispatch achieves low-latency autonomous reasoning, resilient offline operation, and local handling of sensitive emergency communication data while demonstrating real-time agent orchestration, multi-agent reasoning, and autonomous workflow execution on NVIDIA edge hardware.

Challenges we ran into

One of the biggest challenges we faced was learning how to fully utilize the ASUS GX Spark and adapt our development workflow to edge hardware within a hackathon environment. Most of our team had limited prior experience working with local AI inference systems and autonomous agent orchestration on-device, so a significant portion of development involved rapidly learning the hardware stack, configuring local inference pipelines, and optimizing around edge deployment constraints.

Another major challenge involved working with large local models under strict time constraints. Downloading, configuring, and running multiple Nemotron models locally introduced significant setup latency early in development, which reduced valuable iteration time during the hackathon.

One of the harder challenges was making the system react continuously without becoming unsafe or noisy. Early versions could re-run triage too often, speak over the live transcript, or dispatch too eagerly as partial information arrived. We had to add stronger coordination logic: confidence thresholds for triage, speaker-aware transcript events, human approval gates for dispatch.proposed, and stop/cancel handling for TTS so the demo behaved like a real emergency workflow instead of a scripted UI animation.

Accomplishments that we're proud of

We are particularly proud of transforming a high-stakes operational coordination problem into a functioning autonomous AI system within a hackathon timeframe. One of our largest accomplishments was successfully running real-time autonomous reasoning workflows locally on NVIDIA edge hardware rather than relying on cloud inference.

Dispatch goes beyond passive AI assistance by functioning as an operational co-dispatch agent capable of maintaining situational awareness, dynamically reassessing threats, tracking incident evolution, and autonomously coordinating tool-based workflows during active emergency scenarios.

By running entirely on-device, the system eliminates cloud round-trip latency and enables near real-time operational reasoning and response coordination during rapidly evolving incidents. This local-first architecture also improves operational resilience in environments where connectivity may be unreliable while keeping sensitive emergency communication data fully local to the system.

We are also proud of how quickly our team learned and integrated complex agentic technologies, multi-agent orchestration, autonomous tool-calling workflows, and edge inference systems under significant development constraints within a 24-hour hackathon.

What we learned

Through this project, we gained significant experience designing autonomous AI systems capable of reasoning over live operational data streams in real time. We learned how to build and orchestrate agentic workflows using NVIDIA Nemotron models, OpenClaw orchestration, local edge inference pipelines, asynchronous communication processing, and autonomous tool-calling systems.

We also learned how challenging it is to maintain evolving situational memory and operational context in environments where information changes continuously and decisions must be made under strict latency constraints. Working with edge hardware reinforced the importance of low-latency inference, privacy-preserving architectures, and operational resilience in high-stakes environments such as emergency response.

Beyond the technical aspects of the project, we strengthened our ability to collaborate under pressure, rapidly debug complex orchestration systems, and iteratively refine ambitious ideas into functioning autonomous prototypes within a limited development timeframe.

What's next for Dispatch

Dispatch already demonstrates how autonomous operational agents can actively assist emergency coordination through real-time reasoning, autonomous workflow execution, and low-latency edge inference. What makes the project especially exciting is the massive scope for real-world application once integrated directly with live emergency response infrastructure.

Moving forward, we want to expand Dispatch into a fully integrated multi-agent coordination platform capable of interfacing with CAD systems, responder databases, geospatial mapping systems, and live emergency communication channels. We also plan to extend the system’s autonomous tool-calling capabilities to support more advanced operational actions such as responder allocation, routing optimization, incident prioritization, and large-scale emergency coordination.

Another major area of expansion involves scaling Dispatch into a more advanced multi-agent architecture capable of simultaneously handling multiple incoming emergency calls while maintaining independent situational awareness and context for each active incident. We also plan to strengthen NemoClaw's current implementation by creating stronger guardrails, supervisory agents, and policy-based approval systems to ensure reliable coordination in high-stakes environments.

We loved working on this project and had an amazing experience learning how to leverage the ASUS GX Spark and NVIDIA’s edge AI stack to build real-time autonomous agents!