RepairGrid

An autonomous civic repair network connecting residents, field technicians, and city dispatch. Powered by AWS Bedrock multi-agent AI to safely triage, fix, and verify infrastructure.

Comment

RepairGrid

An autonomous civic infrastructure operations layer powered by AWS Bedrock and Strands Multi-Agent architecture.

💡 Inspiration

Across cities, university campuses, and residential neighborhoods, public infrastructure maintenance is fundamentally broken.

When a streetlight goes dark, a storm drain clogs, or an asphalt cavity turns into a hazardous pothole, citizens are often forced to navigate clunky municipal portals or call 311 hotlines—where complaints can disappear into bureaucratic black holes.

Meanwhile:

  • Field maintenance crews operate on disconnected paper manifests.
  • Municipal dispatchers are overwhelmed by duplicate reports.
  • There is little real-time situational awareness.
  • Citizens have limited visibility into what happens after submitting a complaint.

We asked ourselves:

What if civic infrastructure operated like an intelligent, self-healing grid?

Inspired by the Good Neighbor Agents vision, we built RepairGrid—an autonomous operations layer powered by AWS Bedrock and the Strands Multi-Agent Framework.

RepairGrid connects residents, field technicians, and city supervisors in real time, transforming passive complaints into swift, verified physical repairs without chatbot friction or endless municipal delays.

🚀 What It Does

RepairGrid coordinates civic maintenance through three integrated portals, powered by an autonomous and deterministic Strands Agent graph.

1. 🏠 Resident Hub

Routes: /resident · /report

Frictionless 3-Step Reporting

Citizens can:

  • 📸 Capture photos of infrastructure problems.
  • 🎙️ Use hands-free voice-to-text reporting.
  • 📍 Pin precise GPS coordinates.

Radical Transparency

A real-time 5-stage lifecycle stepper keeps residents informed:

Submitted → Triaged → Dispatched → Repaired → Verified

Agent telemetry is streamed directly to the citizen interface.

Citizen Quality Confirmation

Route: /resident/verify/[id]

Residents can compare Before & After repair photos and confirm the fix with a single tap.

2. 🛠️ Field Technician Portal

Route: /worker

Trade-Specialized Dispatch

A mobile-first dashboard designed for:

  • ⚡ Electricians
  • 🛣️ Road crews
  • 💧 Drainage specialists

Optimized Route Navigation

Technicians receive:

  • Automated travel routing
  • Proximity-based mapping
  • Assigned work orders

Autonomous Lifecycle Execution

Technicians can progress through work orders with one tap:

Accept → En Route → On Site → Start Repair

Proof-of-Repair Submission

Field crews submit:

  • 📸 Completion photos
  • 📝 Attestation notes
  • ✅ Repair completion status

directly from the field.

3. 🏢 Supervisor Mission Control

Route: /operations

Dynamic Community Health Index

A real-time mathematical score measuring infrastructure health across:

  • 💡 Lighting
  • 🛣️ Roads
  • 💧 Drainage

Living GIS Map

Provides real-time geospatial visibility into:

  • Infrastructure incidents
  • Risk levels
  • Technician positions

Human-in-the-Loop Decision Inbox

High-risk hazards and policy exceptions automatically pause the agent workflow and require human operator approval.

Multimodal AI Verification Queue

Amazon Bedrock / Nova vision models automatically analyze repair evidence by comparing pre- and post-repair imagery.

Trust & Governance Center

Provides:

  • SHA-256 evidence integrity
  • Immutable audit logging
  • Transparent action history

🧮 Mathematical Model

Community Health Score

RepairGrid evaluates community infrastructure health using a deterministic formula:

$$

\text{Community Health}

\max\left(10,\min\left(100,100-P+B\right)\right) $$

Where:

Hazard Penalty

$$ P = (4 \cdot N_{\text{critical}}) + (1 \cdot N_{\text{active}}) $$

Resolution Bonus

$$ B = \min(2 \cdot N_{\text{resolved}},10) $$

Each infrastructure category—lighting, roadways, and drainage—is independently evaluated:

$$

H_{\text{category}}

\max\left(20,100-(5\cdot N_{\text{open_issues}})\right) $$

This ensures that the Community Health Score reflects objective physical infrastructure conditions rather than subjective estimations.

🛠️ How We Built It

RepairGrid was architected as a distributed, multi-role web platform.

System Architecture

┌──────────────────────┐
│   Resident Portal    │
└──────────┬───────────┘
           │
┌──────────▼───────────┐
│ Field Worker Portal  │
└──────────┬───────────┘
           │
┌──────────▼───────────┐
│   Mission Control    │
└──────────┬───────────┘
           │
           ▼
┌────────────────────────────┐
│      Next.js 14 App        │
│     REST API + Auth        │
└────────────┬───────────────┘
             │
             ▼
┌────────────────────────────┐
│     FastAPI Backend Core   │
└────────────┬───────────────┘
             │
       ┌─────┴─────┐
       ▼           ▼
┌────────────┐ ┌────────────────────┐
│  Strands   │ │   AWS Bedrock      │
│ Agent Graph│ │                    │
├────────────┤ ├────────────────────┤
│ Intake     │ │ Amazon Nova        │
│ Enrichment │ │ Multimodal Vision  │
│ Dedup      │ │                    │
│ Risk       │ │ Claude 3.5 Sonnet  │
│ Ownership  │ │ Reasoning          │
│ Dispatch   │ │                    │
│ Matching   │ │ Proof Analysis     │
│ Guardian   │ │ Embeddings         │
│ Verification│ │ Triage             │
└────────────┘ └────────────────────┘

🤖 Autonomous Agent Layer

The system is orchestrated using the Strands Multi-Agent Graph SDK.

The pipeline contains 10 specialized deterministic agent nodes:

  1. Intake
  2. Location Enrichment
  3. Spatial Deduplication
  4. Physical Verification
  5. Risk Assessment
  6. Department Ownership
  7. Mission Dispatch
  8. Resource Matching
  9. Guardian Policy Evaluation
  10. Completion Verification

This architecture allows RepairGrid to combine autonomous AI reasoning with deterministic execution and safety controls.

🧠 AI & Vision Backbone

Powered by AWS Bedrock, including:

  • Amazon Nova for multimodal vision.
  • Claude 3.5 Sonnet for reasoning.
  • Automated proof-of-repair analysis.
  • Embeddings and intelligent triage.

Nova analyzes:

  • Resident complaint imagery
  • Technician completion photos
  • Surface defects
  • Debris clearance
  • Bounding-box evidence
  • Physical repair cues

💻 Frontend & UX

Built using:

  • Next.js 14 — App Router
  • TypeScript
  • Tailwind CSS
  • Responsive mobile layouts
  • Dark-mode glassmorphism
  • Interactive SVG lifecycle steppers
  • Browser voice recognition APIs

⚙️ Backend & Safety Engine

Built with FastAPI and Python, providing:

  • Role-based mock authentication
  • Geospatial distance clustering
  • Haversine-based deduplication
  • 30-meter duplicate detection radius
  • Deterministic Guardian Policy enforcement

⚡ Challenges We Faced

1. Preventing Infinite Loops & Hallucinations

Large language models operating in autonomous loops can hallucinate tool parameters or repeatedly trigger actions.

Our Solution

We structured the Strands architecture as a:

  • Directed deterministic graph
  • Strictly typed schema system
  • Guardrail-controlled execution pipeline

This limits uncontrolled agent behavior.

2. Safety Gating for Consequential Actions

An autonomous agent should never have unilateral authority to:

  • Dispatch expensive heavy equipment.
  • Close high-voltage electrical cases.
  • Approve high-risk infrastructure repairs.

Our Solution

We built a Human-in-the-Loop (HITL) Decision Inbox.

When an action exceeds predefined risk thresholds:

Agent Decision
      │
      ▼
Risk Threshold Check
      │
 ┌────┴────┐
 │         │
Low Risk  High Risk
 │         │
 ▼         ▼
Execute   HITL Review
            │
            ▼
     Human Authorization
            │
            ▼
          Execute

The Strands graph pauses execution until the required authorization is provided.

3. Computer Vision Under Variable Lighting

Comparing a broken streetlight photographed at night with a daytime repair photo creates a difficult visual verification problem.

Our Solution

We designed multimodal prompts for Amazon Bedrock that focus on structural physical evidence, including:

  • Fixtures
  • Wires
  • Pole numbers
  • Physical placement
  • Infrastructure geometry

rather than relying purely on ambient lighting or image appearance.

🏆 Accomplishments

End-to-End Working System

Built three fully synchronized, role-based portals:

  • Resident
  • Technician
  • Mission Control

All communicate through the same autonomous infrastructure workflow.

⚡ Sub-Second Agent Execution

The Strands pipeline evaluates incoming civic reports, performs deduplication, and dispatches work in under 1.5 seconds.

📈 97%+ Autonomous Action Rate

Routine civic repairs are processed autonomously, while 100% of high-risk scenarios are gated to human operators.

📸 Citizen Verification

Created a complete accountability loop where residents can directly verify physical repairs using Before & After evidence.

📚 What We Learned

Trust Is Essential for Good Neighbor Agents

Autonomous AI in municipal governance must be transparent.

Exposing:

  • Agent telemetry
  • Lifecycle progress
  • Repair evidence
  • Verification status

can create substantially more trust than hiding the process behind a generic chatbot.

Determinism Beats Unrestricted Autonomy for Physical Safety

The most reliable architecture combines:

Deterministic Rules

  • Guardian safety checks
  • Risk thresholds
  • Distance calculations
  • Policy enforcement

with:

Generative AI

  • Vision inspection
  • Voice transcription
  • Reasoning
  • Evidence analysis

This provides a balance between autonomy, speed, reliability, and safety.

🔮 What's Next

🚁 Autonomous Drone Inspection

Integrate automated drone flyovers to inspect:

  • Roof gutters
  • Bridge crevices
  • Storm drainage
  • Hard-to-reach infrastructure

before dispatching field crews.

📊 Predictive Infrastructure Health

Train predictive time-series models using historical repair data to identify infrastructure likely to fail.

The goal:

Repair infrastructure before it breaks.

Potential applications include:

  • Water pipes
  • Transformers
  • Drainage systems
  • Road surfaces

🏛️ Municipal ERP Integration

Enable bi-directional synchronization with existing municipal work-order platforms, including:

  • Cityworks
  • SAP Plant Maintenance
  • Tyler Technologies

This would allow RepairGrid to operate as an intelligent autonomous layer on top of existing municipal infrastructure systems.

Built With

  • agents
  • amazon-nova
  • artificial-intelligence
  • autonomous-agents
  • aws-bedrock
  • civic-tech
  • computer-vision
  • fastapi
  • gis-mapping
  • human-in-the-loop
  • multi-agent-systems
  • multimodal-ai
  • nextjs
  • python
  • react
  • rest-api
  • safety-guardrails
  • smart-cities
  • speech-to-text
  • strands-agents
  • tailwind-css
  • typescript
Share this project:

Updates

Submission history