Civic Signal Intelligence — Detecting road damage from public chatter, before anyone files a complaint.
Built by Team Iceberg · AI for Bharat Hackathon · February 2026
India has 6.4 million km of roads. Over 150,000 people die in road accidents every year — a significant share caused by potholes, cave-ins, and waterlogged stretches that go unreported for weeks.
Municipal repair systems are complaint-driven. A pothole only gets fixed after enough citizens call a helpline, tweet at an official, or fill out an online form. By then, someone may have already been hurt.
The signals exist. Nobody is listening.
Every day, thousands of Indians post about broken roads on Reddit, complain in YouTube comments, and get covered by local news — in Hindi, Tamil, Telugu, Kannada, and a dozen other languages. Weather data predicts exactly where flooding will make things worse. All of this is public, free, and real-time.
No one is connecting these dots. Until now.
RoadSense AI is a passive early-warning system that monitors public signals — Reddit posts, news articles, YouTube comments, and weather data — and uses a multi-agent AI pipeline to detect emerging road infrastructure damage before complaints are filed.
What it does:
| What it replaces:
|
| Metric | Impact |
|---|---|
| Complaint-to-response lag | 40–60% reduction |
| Early detection rate | 25–35% increase |
| Maintenance costs | Significant savings (proactive vs. reactive) |
| Signal classification accuracy | ≥ 85% |
Fully serverless and event-driven on AWS. No servers to manage, scales to zero when idle.
┌──────────────────────────────────────┐
│ PUBLIC SIGNALS │
│ Reddit · News RSS · YouTube · Weather│
└──────────────┬───────────────────────┘
│
EventBridge (hourly cron)
│
▼
┌─────────────────────┐
│ Scraper Lambda │
│ 4 scrapers in 1 fn │
└──────────┬──────────┘
│
┌────────────▼────────────┐
│ AWS Translate │
│ hi/ta/te/kn/bn → en │
│ + PII anonymisation │
│ + Deduplication │
└────────────┬─────────────┘
│
POST /ingest-signal (API Gateway)
│
▼
┌────────────────────────────────────┐
│ INFERENCE LAMBDA │
│ │
│ ┌─ Classification Agent (Nova Micro)│
│ │ Road-related? Damage type? │
│ │ │
│ ├─ Intent Agent (Nova Micro) │
│ │ Sarcasm? Speculation? Urgency? │
│ │ │
│ ├─ Correlation Agent (Titan V2) │
│ │ Geo + temporal clustering │
│ │ │
│ ├─ Inference Agent (scoring) │
│ │ Confidence 0–100 + severity │
│ │ │
│ └─ Explanation Agent (Nova Lite) │
│ Human-readable AI reasoning │
└──────────────┬─────────────────────┘
│
┌──────────────▼──────────────┐
│ DynamoDB │
│ Incidents + Signals │
└──────────────┬──────────────┘
│
API Gateway (REST)
│
▼
┌──────────────────────────────┐
│ Authority Dashboard │
│ React · S3 · CloudFront │
│ Map + Incidents + Feedback │
└──────────────────────────────┘
Every signal passes through a sequential agent pipeline. Each agent adds structured metadata. No agent makes a final decision alone.
| # | Agent | Model | Input | Output | Cost Control |
|---|---|---|---|---|---|
| 1 | Classification | Nova Micro | Raw English text | is_road_related, damage_type, confidence | Cheapest model; simple task |
| 2 | Intent & Context | Nova Micro | Classified signal | is_problem_report, urgency_level, context_type | Filters noise before expensive steps |
| 3 | Correlation | Titan Embeddings V2 | All recent signals | Signal clusters (500m radius, 7-day window) | Embeddings, not generation |
| 4 | Inference | None (deterministic) | Signal clusters | confidence_score (0–100), severity_level | No model call — pure math |
| 5 | Explanation | Nova Lite | Scored incidents | Human-readable summary | Called once per incident, not per signal |
Plus a Feedback Agent (no model) that processes ground-truth validation from municipal authorities and recalibrates confidence scores.
The confidence score is a weighted composite — no single signal can create a high-confidence incident alone:
| Factor | Max Points | Why |
|---|---|---|
| Source diversity (Reddit + News + YouTube + Weather) | 30 | Multiple independent sources = higher trust |
| Signal count in cluster | 20 | More reports = more likely real |
| Urgency level consensus | 20 | Consistent urgency across signals |
| Classification confidence | 20 | How sure the AI is about damage type |
| Recency (time decay) | 10 | Recent signals weighted higher |
| Weather correlation | 10 | Rain + pothole reports = likely flooding |
| Total (clamped) | 100 |
- Incident created when confidence > 60
- Incident archived when confidence < 30
- Confidence decays over time if no new signals arrive
| Model | $/1K tokens | Used For | Why Not Something Else? |
|---|---|---|---|
| Amazon Nova Micro | $0.000035/$0.00014 | Classification + Intent (per signal) | Cheapest Nova model; no access approval needed; fast structured output |
| Amazon Nova Lite | $0.00006/$0.00024 | Explanation (per incident) | Better prose quality; only called once per incident, not per signal |
| Titan Embeddings V2 | $0.00002 | Correlation clustering | Native to Bedrock; no cross-service latency; optimized for similarity |
The Scraper Lambda runs every hour via EventBridge and pulls from four free, public sources:
| Source | Library | What It Captures | Subreddits / Feeds |
|---|---|---|---|
| PRAW | Citizen complaints, photos, rants | r/bangalore, r/mumbai, r/delhi, r/chennai, r/hyderabad | |
| News RSS | feedparser | Structured reporting on road conditions | Times of India, NDTV, The Hindu, Deccan Herald |
| YouTube | google-api-python-client | Video titles + top comments on pothole/flooding videos | Search: pothole road damage india {city} |
| Weather | urllib (OpenWeatherMap API) | Rainfall, flooding alerts — contextual correlation | Bangalore, Mumbai, Delhi, Chennai, Hyderabad |
Search keywords: pothole road flood traffic damage gaddha sadak saalai rasta (English + Hindi + Tamil + Telugu)
India has 22 official languages. Road complaints don't come in English.
"MG Road par bahut bada gaddha hai" → AWS Translate → "There is a large pothole on MG Road"
(Hindi) (auto-detect) (English — ready for AI agents)
- AWS Translate auto-detects language and translates to English before any agent processing
- Original text and detected language are preserved in metadata for audit
- Supported: Hindi, Tamil, Telugu, Kannada, Bengali, Marathi, Malayalam, Gujarati, Punjabi, Urdu, and 60+ more
- Free tier: 2M characters/month
RoadSense AI is designed to be trustworthy by default:
| Principle | Implementation |
|---|---|
| Public data only | Scrapes only publicly visible posts — no private messages, DMs, or login-required content |
| No individual profiling | Outputs are aggregate geographic intelligence, never about specific people |
| PII anonymisation | Reddit usernames (u/), YouTube handles (@), emails, Indian phone numbers — all stripped before storage (pii.py) |
| Deduplication | Content-hash based dedup prevents double-counting from RSS re-serves and repeat scrapes (dedup.py) |
| Explainable AI | Every incident includes a Nova Lite-generated explanation of the evidence chain |
| Human-in-the-loop | Municipal authorities can validate or dismiss incidents via the Feedback Agent |
| Zero citizen effort | No app to install, no form to fill, no account to create |
Signal (click to expand)
{
"signal_id": "uuid",
"content": "English text (translated if needed)",
"original_content": "raw text in source language",
"translated_content": "English text from AWS Translate",
"detected_language": "hi",
"source": "reddit | news | youtube | weather",
"timestamp": "2026-02-01T10:00:00Z",
"location": {
"coordinates": { "lat": 12.9716, "lon": 77.5946 },
"accuracy_meters": 100,
"address": "MG Road, Bangalore"
},
"classification": {
"is_road_related": true,
"damage_type": "pothole | surface_wear | flooding | general",
"confidence": 0.92
},
"intent": {
"is_problem_report": true,
"urgency_level": "low | medium | high | critical",
"context_type": "direct_report | complaint | warning | news_coverage | ..."
}
}Incident (click to expand)
{
"incident_id": "uuid",
"location": {
"center_coordinates": { "lat": 12.9716, "lon": 77.5946 },
"radius_meters": 500,
"address": "MG Road, Bangalore"
},
"damage_type": "pothole",
"confidence_score": 78,
"severity_level": "low | medium | high | critical",
"status": "active | monitoring | archived",
"explanation": "AI-generated summary referencing source types and languages",
"signal_ids": ["uuid1", "uuid2", "uuid3"],
"created_at": "2026-02-01T10:00:00Z",
"updated_at": "2026-02-02T14:30:00Z",
"confidence_history": [
{ "timestamp": "2026-02-01T10:00:00Z", "score": 65 },
{ "timestamp": "2026-02-02T14:30:00Z", "score": 78 }
]
}Full OpenAPI 3.0 spec: openapi.yaml
| Method | Endpoint | Description |
|---|---|---|
POST | /ingest-signal | Submit a signal for AI processing |
GET | /incidents | List all active incidents |
GET | /confidence/{id} | Get confidence score + history for an incident |
POST | /feedback | Submit ground-truth validation from authorities |
GET | /export | Export incidents as JSON (CSV planned) |
curl examples (click to expand)
# Ingest a Hindi signal
curl -X POST https://api.roadsense.dev/ingest-signal \
-H "x-api-key: $API_KEY" \
-H "Content-Type: application/json" \
-d '{ "content": "MG Road par bahut bada gaddha hai", "source": "reddit", "timestamp": "2026-02-01T10:00:00Z", "location": { "latitude": 12.9716, "longitude": 77.5946, "address": "MG Road, Bangalore" } }'# Get active incidents
curl https://api.roadsense.dev/incidents -H "x-api-key: $API_KEY"# Check confidence for a specific incident
curl https://api.roadsense.dev/confidence/incident-123 -H "x-api-key: $API_KEY"# Submit feedback from field inspection
curl -X POST https://api.roadsense.dev/feedback \
-H "x-api-key: $API_KEY" \
-H "Content-Type: application/json" \
-d '{ "incident_id": "incident-123", "feedback_value": "confirmed", "notes": "Pothole verified, ~2ft wide" }'# Export all incidents
curl https://api.roadsense.dev/export -H "x-api-key: $API_KEY"roadsense-ai/
├── agents/
│ ├── classification_agent.py # Road-related? What damage type? (Nova Micro)
│ ├── intent_agent.py # Sarcasm/speculation filter + urgency (Nova Micro)
│ ├── correlation_agent.py # Geo+temporal clustering (Titan Embeddings V2)
│ ├── inference_agent.py # Confidence scoring (deterministic)
│ ├── explanation_agent.py # Human-readable summaries (Nova Lite)
│ └── feedback_agent.py # Ground-truth recalibration
├── scraper/
│ ├── reddit_scraper.py # PRAW — Indian city subreddits
│ ├── rss_scraper.py # feedparser — Times of India, NDTV, The Hindu, Deccan Herald
│ ├── youtube_scraper.py # YouTube Data API v3 — video titles + comments
│ └── weather_scraper.py # OpenWeatherMap — rainfall + flood alerts
├── data/
│ ├── generate_signals.py # Synthetic dataset generator
│ ├── signals.json # 1,050 signals (850 EN + 200 multilingual)
│ └── synthetic_incidents.json # 10 mock incidents for dashboard development
├── tests/
│ ├── test_properties.py # 50 property-based tests (Hypothesis)
│ ├── test_intent_agent.py # 45 unit tests — Intent & Context Agent
│ ├── test_inference_agent.py # 55 unit tests — Inference Agent
│ ├── test_api_integration.py # 30 integration tests (skip when API offline)
│ └── test_translate.py # 5 unit tests — AWS Translate wrapper
├── translate.py # AWS Translate wrapper — auto-detect + translate
├── pii.py # PII anonymisation (usernames, emails, phones)
├── dedup.py # Content-hash deduplication
├── location_normaliser.py # Normalise location formats across sources
├── locustfile.py # Load test config — 1,000 signals/hour target
├── openapi.yaml # OpenAPI 3.0 specification
└── .gitignore
185 tests across 5 test suites. Zero failures.
$ pytest tests/ -v --tb=short
155 passed, 0 failed, 30 skipped ✓
(30 skipped = API integration tests; dev API not yet deployed)
| Suite | Tests | What It Validates |
|---|---|---|
| Property-based (test_properties.py) | 50 | 35 correctness properties via Hypothesis — confidence bounds, thresholds, severity ordering, decay monotonicity, scoring weights |
| Intent Agent (test_intent_agent.py) | 45 | Prompt construction, response parsing, sarcasm/speculation handling, weather pre-classification, fallback logic, Lambda handler |
| Inference Agent (test_inference_agent.py) | 55 | Confidence scoring, severity computation, incident creation/archival thresholds, time decay, cluster processing |
| API Integration (test_api_integration.py) | 30 | End-to-end ingestion, incident retrieval, confidence checks, export, error handling (auto-skipped when API unreachable) |
| Translate (test_translate.py) | 5 | Hindi/Tamil/Telugu translation, English passthrough, empty content handling |
# All tests
pytest tests/ -v
# Property-based tests only
pytest tests/test_properties.py -v --hypothesis-seed=0
# Load test (Locust) — requires live API
locust -f locustfile.py --host=https://api.roadsense.dev
# Opens http://localhost:8089 — configure users and spawn rate# Headless: locust -f locustfile.py --host=https://api.roadsense.dev --users 10 --spawn-rate 2 --run-time 5m --headlesssignals.json — 1,050 signals for development and testing:
| Category | Count | Purpose |
|---|---|---|
| Road-related (genuine reports) | 350 | True positives — potholes, flooding, surface wear |
| Non-road (noise) | 250 | True negatives — traffic jams, politics, unrelated |
| Sarcastic | 100 | Adversarial — "Oh wow another beautiful pothole" |
| Ambiguous | 100 | Edge cases — could be road-related, unclear |
| Multilingual (hi/ta/te) | 200 | Hindi (69), Tamil (70), Telugu (61) — translation pipeline testing |
| Edge cases | 50 | Empty content, missing fields, extreme coordinates |
Plus synthetic_incidents.json — 10 mock incidents across Bangalore locations (Electronic City, MG Road, Silk Board, Whitefield, Koramangala, Indiranagar) for the Authority Dashboard.
| Layer | Service | Detail |
|---|---|---|
| Scraping | Lambda + EventBridge | Hourly cron; PRAW, feedparser, google-api-python-client, urllib |
| Translation | AWS Translate | Auto-detect → English; 10+ Indian languages; 2M chars/month free |
| Ingestion | API Gateway + Lambda | REST endpoint; JSON validation; S3 raw storage |
| AI Reasoning | Amazon Bedrock | Amazon Nova Micro, Amazon Nova Lite, Titan Embeddings V2 |
| Vector Store | ChromaDB | Semantic similarity for signal correlation |
| Storage | DynamoDB + S3 | Incident state in DynamoDB; raw signals archived in S3 |
| API | API Gateway | REST/JSON; API key auth; 5 endpoints |
| Frontend | React + S3 + CloudFront | Map view, incident cards, confidence gauges, feedback forms |
| Testing | pytest + Hypothesis + Locust | Property-based, unit, integration, and load testing |
| CI/CD | SAM CLI | sam build && sam deploy --guided |
| Requirement | Notes |
|---|---|
| Python 3.11+ | Agent code + scrapers |
| Node.js 18+ | React dashboard |
| AWS CLI | Configured with IAM permissions for Lambda, Bedrock, Translate, DynamoDB, S3, CloudFront |
| Bedrock model access | Nova Micro, Nova Lite, and Titan Embeddings V2 are available in us-east-1 without manual approval |
| Reddit API credentials | reddit.com/prefs/apps — free, instant |
| YouTube Data API v3 key | Google Cloud Console — free under 10K units/day |
| OpenWeatherMap API key | openweathermap.org/api — free tier, 1000 calls/day |
# Clone
git clone https://github.com/Sujith-RMD/RoadSense-AI.git
cd RoadSense-AI
# Python environment
python -m venv venv
source venv/bin/activate # Linux/Mac
venv\Scripts\activate # Windows# Install dependencies
pip install boto3 praw feedparser google-api-python-client chromadb
pip install pytest hypothesis locust # testing# Environment variablesexport REDDIT_CLIENT_ID=...
export REDDIT_CLIENT_SECRET=...
export YOUTUBE_API_KEY=...
export OPENWEATHERMAP_API_KEY=...
export AWS_DEFAULT_REGION=ap-south-1
# Run tests (no AWS credentials needed)
pytest tests/ -v# Backend — Lambda + API Gateway + DynamoDB
sam build
sam deploy --guided
# Frontend — React dashboardcd dashboard
npm install && npm run build
aws s3 sync ./build s3://<frontend-bucket> --delete
# CloudFront distribution URL → hackathon submission link| Name | Role | Owns | |
|---|---|---|---|
| ⚙️ | Srikar | AWS & Backend | API Gateway, Lambda, S3, DynamoDB, CloudFront, Bedrock access, IAM, CloudWatch, bedrock_client.py |
| 🤖 | Durva | AI Pipeline & Data | All 4 scrapers, AWS Translate integration, 5 AI agents, PII anonymisation, deduplication |
| 🎨 | Nishita | Frontend & UX | Figma design system, Authority Dashboard (React), map view, incident detail, confidence gauge, feedback form |
| 🧪 | Sujith | QA & Documentation | 1,050-signal synthetic dataset, 185 tests (property-based + unit + integration + load), OpenAPI spec, README, demo script |
| Term | Definition |
|---|---|
| Signal | Any unstructured text from a public source that may contain road condition information |
| Incident | A geo-located road infrastructure problem detected by the system, with a confidence score and AI explanation |
| Confidence Score | 0–100 composite metric reflecting the system's certainty about detected road damage |
| Source Diversity | Number of distinct source types (Reddit, news, YouTube, weather) contributing evidence — higher diversity = higher confidence |
| Temporal Density | Concentration of related signals within a time window — rapid signal bursts indicate active/worsening problems |
| Ground Truth | Post-detection validation by municipal authorities — used to recalibrate confidence scoring |
| Authority Dashboard | React web app for municipal officials to view, prioritize, and provide feedback on detected incidents |
RoadSense AI — Team Iceberg · AI for Bharat Hackathon 2026
Detecting the potholes nobody reported — from the signals everyone already posted.