From prompts to production routing system.
Monday: 3 core prompts for route planning. Tuesday: automation code with LangGraph. Wednesday: team workflows across dispatch, drivers, and ops. Thursday: complete technical architecture. Multi-agent coordination, real-time optimization, ML-driven predictions, and scaling patterns for 10,000+ routes daily.
Key Assumptions
System Requirements
Functional
- Ingest orders (address, time window, priority, size/weight)
- Optimize routes considering distance, time, capacity, constraints
- Real-time re-routing on traffic, delays, cancellations
- Driver assignment based on skills, location, availability
- ETA prediction with 90%+ accuracy (±15 min)
- Cost tracking: fuel, labor, vehicle wear per route
- Analytics: route efficiency, on-time %, cost per delivery
Non-Functional (SLOs)
💰 Cost Targets: {"per_route_usd":0.05,"per_vehicle_per_day_usd":2,"ml_inference_per_1k_routes_usd":5}
Agent Layer
planner
L3Decompose routing problem into solvable sub-problems (clustering, sequencing, assignment)
🔧 GeospatialClusteringTool (DBSCAN, k-means), ConstraintAnalysisTool (feasibility check), StrategySelector (problem size → algorithm)
⚡ Recovery: If clustering fails → fallback to simple geographic bounds, If infeasible constraints → relax time windows incrementally, If no strategy matches → default to greedy nearest-neighbor
executor
L4Run VRP solver with ML-enhanced cost functions (traffic, weather, historical patterns)
🔧 VRPSolver (OR-Tools, Gurobi, or custom), MLCostPredictor (traffic impact, ETA), DistanceMatrixAPI (Google Maps)
⚡ Recovery: If solver timeout → return best-so-far solution, If ML predictor fails → fallback to historical averages, If API rate limit → use cached distance matrix
evaluator
L2Validate route quality (capacity, time windows, cost, ETA accuracy)
🔧 CapacityValidator (sum weights per vehicle), TimeWindowValidator (arrival vs deadline), CostAnalyzer (compare to historical baseline)
⚡ Recovery: If violations found → flag for human review, If quality_score < 70 → trigger re-optimization, If critical violation (safety) → block deployment
guardrail
L1Enforce safety policies (max drive time, rest periods, hazmat restrictions)
🔧 SafetyPolicyEngine (rule-based checks), DriverComplianceChecker (hours of service), HazmatValidator (route restrictions)
⚡ Recovery: If policy violation → block route, alert dispatcher, If driver unavailable → reassign to backup driver, If hazmat route invalid → reroute avoiding restricted zones
rebalancer
L3Dynamically adjust routes based on real-time events (traffic, cancellations, new orders)
🔧 TrafficMonitor (live traffic API), EventProcessor (order updates, driver status), IncrementalOptimizer (local search, 2-opt)
⚡ Recovery: If traffic API down → use cached data (5min stale), If rebalancing infeasible → maintain current routes, If cost increase > 20% → require dispatcher approval
eta_predictor
L2ML-driven ETA predictions considering traffic, weather, driver behavior
🔧 TrafficModel (XGBoost on historical patterns), WeatherImpactModel (rain → 15% slower), DriverBehaviorModel (speed profile)
⚡ Recovery: If ML model fails → fallback to distance/speed formula, If confidence < 60% → widen interval to ±30min, If historical data missing → use city-wide averages
ML Layer
Feature Store
Update: Real-time (traffic), Hourly (weather), Daily (historical aggregates)
- • traffic_speed_by_road_segment (5min intervals)
- • weather_conditions (rain, snow, temp)
- • historical_delivery_times (by time_of_day, day_of_week)
- • driver_speed_profile (avg speed, variability)
- • order_density_heatmap (orders per km²)
- • vehicle_utilization (capacity used %)
Model Registry
Strategy: Semantic versioning (major.minor.patch), A/B test new models at 10% traffic
- • ETA Predictor
- • Demand Forecaster
- • Route Clustering
Observability Stack
Real-time monitoring, tracing & alerting
0 activeDeployment Variants
Startup Architecture
Fast to deploy, cost-efficient, scales to 100 competitors
Infrastructure
Risks & Mitigations
⚠️ VRP solver timeout on large problems (>500 stops)
Medium✓ Mitigation: Implement hierarchical optimization (cluster → optimize clusters → merge). Set hard timeout (60sec) with best-so-far fallback. Use heuristics (genetic algorithm, simulated annealing) for large problems.
⚠️ Google Maps API cost explosion ($10K+/mo)
High (if not monitored)✓ Mitigation: Cache distance matrix (1hr TTL), implement rate limiting (100 req/sec), use OSM as backup, negotiate volume pricing with Google, monitor daily spend with alerts.
⚠️ ML model drift (ETA accuracy drops from 90% to 70%)
Medium✓ Mitigation: Monitor ETA accuracy daily, alert if <85%, retrain model weekly, A/B test new models, keep 3 model versions in registry for rollback.
⚠️ Real-time traffic data unavailable (API outage)
Low✓ Mitigation: Use historical traffic patterns as fallback, cache traffic data (5min TTL), switch to backup provider (Waze, TomTom), accept degraded accuracy (±15min) temporarily.
⚠️ Driver non-compliance (ignoring optimized routes)
Medium✓ Mitigation: Gamification (leaderboard, bonuses for following routes), real-time coaching (in-app nudges), analytics dashboard for fleet managers, escalation for repeated violations.
⚠️ Data privacy breach (customer addresses leaked)
Low✓ Mitigation: Encrypt addresses at rest (AES-256), redact in logs, store as lat/lng + geohash, implement RBAC (least privilege), audit all access, pen-test quarterly.
⚠️ Multi-tenancy data leakage (Tenant A sees Tenant B's routes)
Low✓ Mitigation: Row-level security (RLS) in PostgreSQL, tenant_id in all queries, separate schemas per tenant (enterprise), automated testing for cross-tenant access, regular security audits.
Evolution Roadmap
Progressive transformation from MVP to scale
Phase 1: MVP (0-3 months)
Phase 2: Scale & ML (3-6 months)
Phase 3: Enterprise & Multi-Region (6-12 months)
Complete Systems Architecture
9-layer architecture from driver app to ML models
Presentation
4 components
API Gateway
4 components
Agent Layer
4 components
ML Layer
4 components
Integration
4 components
Data
4 components
External
4 components
Observability
4 components
Security
4 components
Sequence Diagram - Route Optimization Request
Automated data flow every hour
Data Flow - Order to Delivery
Key Integrations
Google Maps Platform
Weather API (OpenWeather)
TMS (Transportation Management System)
Telematics (GPS Tracking)
Payment Gateway (Stripe)
Security & Compliance
Failure Modes & Fallbacks
| Failure | Fallback | Impact | SLA |
|---|---|---|---|
| Google Maps API down or rate limited | Use cached distance matrix (1hr stale) → OpenStreetMap (OSM) as backup → Manual distance estimation (haversine formula) | Degraded accuracy (±10% distance error), slower optimization | 99.5% (Maps API SLA: 99.9%) |
| VRP solver timeout (>60sec) | Return best-so-far solution (may be suboptimal) → Greedy nearest-neighbor as last resort | Routes 5-15% less efficient, but still valid | 99.0% |
| ML model prediction fails (ETA, demand) | Use historical averages (last 30 days) → Simple distance/speed formula | ETA accuracy drops from 90% to 75% | 99.5% |
| Database unavailable (PostgreSQL) | Read from replica (eventual consistency) → Cache (Redis) for recent data → Fail gracefully (return 503) | Read-only mode, no new routes generated | 99.9% (RDS Multi-AZ) |
| Guardrail agent detects policy violation (e.g., max drive time exceeded) | Block route deployment → Alert dispatcher → Suggest manual adjustment | Safety maintained, but manual intervention required | 100% (safety-critical) |
| Real-time traffic data unavailable | Use historical traffic patterns (by time_of_day, day_of_week) → Assume free-flow speed | ETA accuracy drops by 10-15% | 99.0% |
| Kafka message broker down | Buffer events in Redis (limited capacity) → Fall back to synchronous processing → Alert on-call | Increased latency, risk of data loss if buffer full | 99.5% |
┌──────────────┐
│ Orchestrator │ ← Coordinates all agents, manages state
└──────┬───────┘
│
┌───┴────┬─────────┬──────────┬──────────┬─────────┐
│ │ │ │ │ │
┌──▼──┐ ┌─▼───┐ ┌──▼────┐ ┌──▼────┐ ┌──▼───┐ ┌─▼──┐
│Plan │ │Exec │ │Eval │ │Guard │ │Rebal │ │ETA │
│Agent│ │Agent│ │Agent │ │Agent │ │Agent │ │Pred│
└──┬──┘ └──┬──┘ └───┬───┘ └───┬───┘ └──┬───┘ └─┬──┘
│ │ │ │ │ │
│ └─────────┴──────────┴─────────┘ │
│ │ │
└──────────────────────┴──────────────────────────┘
│
┌──────▼──────┐
│ Database │
│ (Routes) │
└─────────────┘🔄Agent Collaboration Flow
🎭Agent Types
Reactive Agent
LowETA Predictor - Receives route segment, returns ETA
Reflexive Agent
MediumEvaluator Agent - Uses rules + context (capacity, time windows)
Deliberative Agent
HighPlanner Agent - Plans clustering strategy based on problem size
Orchestrator Agent
HighestCoordinator - Makes routing decisions, handles loops, manages state
📈Levels of Autonomy
RAG vs Fine-Tuning for Route Planning
Hallucination Detection in Route Planning
Evaluation Framework
Dataset Curation for Route Optimization
Agentic RAG for Dynamic Routing
Online Learning for ETA Prediction
Tech Stack Summary
Need Route Optimization Architecture?
We'll design your production system: multi-agent coordination, ML-driven optimization, and scaling to 10,000+ routes/day.
2026 Randeep Bhatia. All Rights Reserved.
No part of this content may be reproduced, distributed, or transmitted in any form without prior written permission.