Building Commute Copilot Bangalore with Amazon Bedrock, AgentCore, and Kiro
A hackathon build story on creating a multi-agent commute intelligence system for Bengaluru using Amazon Bedrock, Bedrock AgentCore, LangGraph, Kiro, Elastic retrieval, and Kibana. The article covers the agent architecture, AWS deployment flow, and how Kiro helped with coding and deployment side by side.
I built Commute Copilot Bangalore at HackNight Bengaluru: Build AI Agents, hosted by AWS User Group Bengaluru.
The problem statement was Commute Intelligence for Bengaluru.
The idea was simple: Bengaluru commute decisions are not just about the shortest route. A real commute decision depends on traffic, Metro/BMTC feasibility, parking, rain, last-mile walking, and route reliability.
So instead of building another route planner, I built a multi-agent commute intelligence system that recommends the best commute option with reasoning.
Example output:
Leave in 18 minutes. Take Metro + walk. Traffic risk is high near Domlur, parking is unreliable, rain risk is manageable, and Metro is more predictable.
Architecture
The project was built around:
LangGraph orchestration + Amazon Bedrock reasoning + Elastic retrieval + AWS Bedrock AgentCore deployment
Core flow:
1
2
3
4
5
6
7
8
9
10
11
User Query
↓
LangGraph StateGraph
↓
Weather Agent + Route/Traffic Agent + Transit Agent
↓
Supervisor Agent
↓
Final Recommendation
↓
Elasticsearch Logs + Kibana
Agent Design
The system had four main agents:
Weather Agent
Uses Open-Meteo API and fallback data to calculate rain risk and walking comfort.
Route + Traffic Agent
Uses OSRM/OpenStreetMap, route fallback data, traffic hotspot logic, and Elastic retrieval to compare routes by duration, congestion, parking risk, and reliability.
Transit Context Agent
Checks Metro/BMTC feasibility, nearest stations, last-mile effort, and public transport reliability using curated Bengaluru commute context.
Supervisor Agent
Aggregates all agent outputs, compares evidence, selects the final route/mode, and generates reasoning, alternatives, risks, and confidence score.
AWS Stack
The model layer was built using Amazon Bedrock through LangChain + langchain-aws.
For the hackathon demo, Amazon Nova Lite powered the Supervisor, Route + Traffic, Weather, and Transit agents. The project config also supports Claude 3.5 Sonnet as a fallback for heavier Supervisor and Route reasoning.
The full agent system was deployed on AWS Bedrock AgentCore, with an AgentCore CDK scaffold for deployment.
AgentCore helped move the project from a local LangGraph workflow toward a deployable agent runtime.
Retrieval and Observability
For grounding, I used Elasticsearch on Elastic Cloud Serverless with:
- structured search
- vector search
- hybrid retrieval
- route-risk lookup
- decision logging
For embeddings, I used Jina Embeddings v5 text small to generate dense vectors for commute context, route summaries, and previous decisions.
For observability, I used Kibana to inspect indexed data, decision logs, and agent outputs.
How Kiro Helped
A huge part of the build was handled with Kiro.
During the hackathon, coding and deployment had to happen side by side. Usually, that becomes messy: first you build locally, then you rush deployment at the end.
With Kiro, I could work more iteratively.
While building the LangGraph workflow, tools, Elastic integration, and ingestion scripts, Kiro helped with:
- navigating the codebase faster
- generating and modifying agent/tool code
- debugging integration issues
- working through AWS deployment steps
- setting up the AgentCore deployment scaffold
- keeping the local build and cloud deployment aligned
That made a big difference in a 5-hour hackathon environment.
Instead of treating deployment as the last step, I could keep coding and deploying in parallel.
What I Built in 5 Hours
In around 5 hours, the project came together with:
- multi-agent orchestration using LangGraph
- Amazon Bedrock model integration
- Amazon Nova Lite powered agents
- AgentCore deployment scaffold
- Elastic vector retrieval
- Jina embeddings
- Python ingestion pipeline
- Open-Meteo weather integration
- OSRM/OpenStreetMap route data
- Kibana logs and dashboards
Link to Github repo:
https://github.com/Srish-ty/commute-copilot-bangaloreIt was chaotic, but the good kind of chaotic.
Final Thoughts
Commute Copilot Bangalore is still a hackathon MVP, but the idea feels useful because commute decisions in Bengaluru are messy and context-heavy.
The best route is not always the fastest route.
Sometimes, it is the most predictable one.
This project was a fun way to combine agentic AI, Amazon Bedrock, Bedrock AgentCore, Kiro, retrieval, and observability into a real-world problem that almost every Bengaluru commuter understands.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article