AsyncAwait547/OmniDispatch: critical infrastructure failures (power grid overloads, telecom outages

Autonomous Critical Infrastructure Dispatch Orchestrator Microsoft Agents League Hackathon 2026 — Reasoning Agents Track

"When a transformer overloads at 2 AM, the average utility takes 47 minutes to dispatch a repair crew. Every minute costs $9,000 in cascading damages. OmniDispatch reduces that to 3 seconds — with full human oversight."

🎯 The Problem

Critical infrastructure failures (power grid overloads, telecom outages, pipeline leaks) require immediate coordinated response across three isolated domains:

Today, human operators manually cross-reference these three systems. It takes an average of 47 minutes from telemetry alert to technician dispatch. OmniDispatch eliminates this bottleneck.

⚡ The Solution

OmniDispatch is a multi-agent AI orchestration platform that:

1. Fans out three specialized AI agents in parallel using the ConcurrentBuilder pattern
2. Merges their outputs instantly through a custom zero-latency aggregator (no extra LLM call)
3. Halts the execution graph for Human-in-the-Loop (HITL) approval before any dispatch is authorized
4. Traces every agent span via OpenTelemetry for full auditability

┌─────────────────────────────────────────────────────────────────┐
│               OMNIDISPATCH ARCHITECTURE                        │
│                                                                 │
│  Telemetry Alert ──→ ConcurrentBuilder (Fan-Out)               │
│                        ├── Analysis Agent (IoT Classification)  │
│                        ├── Policy Agent (Azure AI Search RAG)   │
│                        └── Logistics Agent (SQL MCP Routing)    │
│                               │                                 │
│                        Custom Aggregator (Zero-Latency Merge)   │
│                               │                                 │
│                        HITL Signature Lock ⟵ HUMAN OPERATOR    │
│                               │                                 │
│                        Dispatch Authorized ──→ Field Units      │
└──────────────────────���──────────────────────────────────────────┘

Before vs. After

🏗️ System Architecture

   ┌─────────────────────────────────────────────────────────────┐
   │                  Microsoft Copilot Canvas                   │
   │   - Interactive Fluent UI HTML Map Widget (Port 3000)      │
   │   - OpenAPI-discovered tools via MCP Protocol              │
   └───────────────┬─────────────────────────────▲───────────────┘
                   │                             │
       [1] Telemetry Alert            [5] Renders Widget (HTML)
                   │                             │
   ┌───────────────▼─────────────────────────────┴───────────────┐
   │              Azure AI Foundry Agent Service                 │
   │               - FastAPI (Port 8088, Responses Protocol)     │
   │   ┌─────────────────────────────────────────────────────┐   │
   │   │        Microsoft Agent Framework v1.0 (MAF)         │   │
   │   │             - ConcurrentBuilder Orchestrator        │   │
   │   │                                                     │   │
   │   │   ┌───────────────┬─────────────────┬───────────┐   │   │
   │   │   │ Analysis Agent│  Policy Agent   │ Logistics │   │   │
   │   │   │(Azure OpenAI) │(AI Search RAG)  │ Agent     │   │   │
   │   │   └───────┬───────┴────────┬────────┴─────┬─────┘   │   │
   │   │           └──────────────┐ │ ┌───────────��┘         │   │
   │   │                          ▼ ▼ ▼                      │   │
   │   │              [2] Custom Aggregator                  │   │
   │   │                     (Zero-Latency)                  │   │
   │   │                          │                          │   │
   │   │              [3] Cryptographic HITL                 │   │
   │   │           (approval_mode='always_require')          │   │
   │   └──────────────────────────┬──────────────────────────┘   │
   └──────────────────────────────┼──────────────────────────────┘
                                  │
                       [4] Dispatch Signed & Approved
                                  ▼
                     [Field Dispatch Hardware Units]

Technology Stack

✨ Key Features

Real-Time Control Room

• Live WebSocket Streaming: Telemetry alerts broadcast instantly to the React dashboard
• OTel Waterfall Gantt Trace: Animated visualization of parallel agent execution with per-span latency
• Voice Synthesis Alerts: Web Speech API announces critical incidents and dispatch confirmations
• Severity Heatmap: Color-coded grid sectors (Critical/High/Moderate/Low) on the canvas map
• Multi-Incident Queue: Handles concurrent incidents with auto-load on dispatch completion
• PDF Audit Export: One-click compliance report with cryptographic hashes

Multi-Agent Orchestration

• ConcurrentBuilder Pattern: Three agents execute simultaneously, not sequentially
• Custom Aggregator: Compiles parallel outputs without triggering additional LLM inference
• Hybrid Agents: Transparently use Azure OpenAI when configured, fall back to deterministic mocks

Enterprise Safety

• HITL Enforcement: @ai_function(approval_mode='always_require') halts the execution graph
• Cryptographic Audit Trail: Every dispatch generates a unique AUDIT-{id}-{uuid} token
• Compliance Grounding: Policy agent retrieves real regulations from Azure AI Search

📁 Project Structure

OmniDispatch/
├── azure.yaml                    # Azure Developer CLI deployment manifest
├── infra/
│   └── main.bicep                # Infrastructure-as-Code (all Azure resources)
├── agent/
│   ├── Dockerfile                # Multi-stage production container (non-root)
│   ├── agent.yaml                # Foundry Agent Service manifest
│   ├── requirements.txt          # Python dependencies (Azure SDKs included)
│   ├── .env.example              # Environment variable template
│   ├── main.py                   # FastAPI server (Responses Protocol, WebSocket, Telemetry)
│   ├── agent_logic.py            # HybridAgent orchestration (Azure OpenAI + AI Search + MAF)
│   ├── mock_services.py          # Deterministic fallback agents and mock databases
│   ├── telemetry_generator.py    # IoT sensor simulator for live demos
│   └── test_system.py            # Automated verification tests
├── mcp-server/
│   ├── server.js                 # MCP tool endpoints + Copilot Canvas integration
│   ├── ai-plugin.json            # Copilot plugin manifest (tool discovery)
│   └── public/
│       ├── openapi.json          # OpenAPI 3.1 specification
│       └── map_widget.html       # Fluent UI interactive dispatch map
├── Frontend/
│   └── src/
│       └── routes/
│           ├── index.tsx          # Landing page
│           ├── control-room.tsx   # Real-time dispatch console (WebSocket, OTel, Voice)
│           ├── architecture.tsx   # System architecture visualization
│           ├── agents.tsx         # Agent capability showcase
│           ├── compliance.tsx     # Regulatory compliance dashboard
│           └── deployments.tsx    # Deployment status monitor
└── run_local.ps1                 # One-command local startup script

🚀 Getting Started

Prerequisites

• Python 3.11+
• Node.js 18+
• (Optional) Azure subscription for real AI services

Quick Start (Local)

# Clone the repository
git clone https://github.com/your-org/OmniDispatch.git
cd OmniDispatch

# Run the automated startup script
.\run_local.ps1

This starts three services:

Connecting Real Azure Services (Optional)

# Copy the environment template
cp agent/.env.example agent/.env

# Fill in your Azure credentials
# See the "Azure Setup Guide" section below

Azure Deployment

# Install Azure Developer CLI
winget install Microsoft.Azd

# One-command provisioning and deployment
azd up

🔑 Azure Setup Guide

To connect OmniDispatch to real Azure AI services:

Step 1: Create Azure OpenAI Resource

1. Go to Azure Portal → Create → "Azure OpenAI"
2. Deploy a gpt-4o model
3. Copy the Endpoint and API Key from the resource's "Keys and Endpoint" page

Step 2: Create Azure AI Search Resource

1. Go to Azure Portal → Create → "Azure AI Search"
2. Create an index named omnidispatch-policies
3. Upload safety regulation documents (PDFs)
4. Enable Semantic Search configuration

Step 3: Configure Environment Variables

# In agent/.env
AZURE_OPENAI_ENDPOINT=https://your-resource.openai.azure.com/
AZURE_OPENAI_API_KEY=your-key
AZURE_OPENAI_DEPLOYMENT=gpt-4o
AZURE_SEARCH_ENDPOINT=https://your-search.search.windows.net
AZURE_SEARCH_KEY=your-key
AZURE_SEARCH_INDEX=omnidispatch-policies

What's Real vs. What's Simulated

Note: The HITL approval, WebSocket streaming, OTel tracing, PDF export, and Control Room are fully real in both modes. Only the LLM inference and RAG search switch between Azure and mock.

🧪 Testing

# Run automated verification tests
cd agent
python test_system.py

# Check system health and Azure connectivity
curl http://localhost:8088/

# Send a test telemetry alert
curl -X POST http://localhost:8088/telemetry -H "Content-Type: application/json" -d '{"incident_id":"INC-TEST-001","failure_type":"Transformer Overload","severity":"Critical","grid_zone":"North-East Sector (NE-04)","metrics":{"temperature_c":115.4,"coolant_level_percent":14.2,"load_percentage":138.5}}'

🏆 Hackathon Rubric Alignment

📋 Copilot Canvas Integration

OmniDispatch integrates with Microsoft Copilot Canvas via the Model Context Protocol (MCP):

1. Plugin Discovery: ai-plugin.json + openapi.json at /.well-known/ai-plugin.json
2. Tool Invocation: Copilot calls /tools/show_assignments_on_map to render interactive HTML widgets
3. Theme Adaptation: Widgets detect Copilot's light/dark mode via CSS media queries
4. Real-Time Data: Widget connects to the Agent Service WebSocket for live incident updates

Copilot Canvas ←→ MCP Server (Port 3000) ←→ Agent Service (Port 8088)
                     │                              │
              Tool Discovery               WebSocket Streaming
              Widget Rendering             Telemetry Processing
              OpenAPI Spec                 HITL Approval

🎬 Demo Video

📹 Watch the 3-minute demo video → (Add link after recording)

The demo shows:

1. A live telemetry alert arriving via WebSocket
2. Three agents executing in parallel (visible on the OTel Gantt trace)
3. Voice synthesis announcing the incident
4. Human operator authorizing the dispatch
5. PDF audit report generation

📄 License

MIT License — See LICENSE for details.