Introduction-
Disaster response is one of the most critical areas where speed and coordination matter. When I joined the Google & Kaggle 5-Day AI Agents Intensive, I didn't just want to build another chatbot. I wanted to build a system that could actually do something in a high-stakes environment.
My Capstone Project, DRCA (Disaster Resource Coordination Agent), is a multi-agent system designed to streamline rescue operations by coordinating logistics, geolocation, and resource allocation instantly.
Learning Reflections-
Before this course, I viewed AI largely as a "Knowledge Engine"—something you ask questions to. The biggest shift in my mental model was understanding AI as an "Action Engine."
Key Concepts That Resonated-
🛠️Tool Use (Function Calling): The moment I connected Gemini to the Google Maps API, everything changed. Realizing that an LLM can "decide" to call a function, get coordinates, and then use that data to make a logistics decision was a breakthrough. It turned the model from a writer into a router.
🤖Multi-Agent Orchestration: Building DRCA taught me that one giant prompt is rarely the answer. Splitting the brain into a "Triage Agent" (who assesses urgency) and a "Logistics Agent" (who finds the route) made the system far more reliable and debuggable.
How My Understanding Evolved-
I used to think the smartness of an agent came from the model size. Now I realize the smartness comes from the architecture. A smaller model with well-defined tools and a clear system prompt often outperforms a larger model with a vague instruction.
Capstone Project: DRCA
The Problem-
In the chaos of a disaster (flood, earthquake), human dispatchers are overwhelmed. Matching a victim's request ("We are stuck on the roof at Sector 4") to available resources ("Boat A is 2km away") takes too long manually.
The Solution
DRCA is an automated dispatcher that uses a multi-agent workflow to:
Parse incoming distress messages (even in multiple languages).
Geolocate the incident using mapping tools.
Calculate the distance to the nearest available rescue unit.
Dispatch the unit and update the status.
How It Works(The Architecture)
I built this using Google Gemini Pro as the reasoning engine. The system is composed of three primary agents:
🗣️Intake Agent: Handles user communication and extracts intent.
🗺️Geospatial Agent: Interfaces with map data to calculate distances and routes.
🚚Dispatch Agent: Assigns resources based on the Geospatial Agent's data.
_The Logic (Code Snippet)_
One of the most challenging parts was getting the agent to reliably choose the "closest" unit. Here is a simplified look at the routing logic:
The Dispatch Agent evaluates candidates based on distance
def find_nearest_unit(incident_loc, available_units):
candidates = []
for unit in available_units:
# The agent uses a tool to calculate real-world distance
distance = calculate_distance(incident_loc, unit.location)
candidates.append((unit, distance))
# Sort by distance and return the optimal unit
return sorted(candidates, key=lambda x: x[1])[0]
*Demo Video- *
Here is the system in action. You can see the agents handing off tasks from Triage to Dispatch in real-time.
Future Improvements-
While the current version works for text-based coordination, I plan to integrate:
<🎙️Voice Inputs: Allowing victims to send audio messages that are transcribed and processed.
<👁️Vision Capabilities: allowing the agent to analyze images of the disaster scene to estimate severity.
Conclusion-
The 5-Day Intensive was a crash course in the future of software. Building DRCA showed me that we are moving away from writing code that solves problems, to writing code that manages agents that solve problems.
🙏 Thanks for Reading!
If you found this breakdown helpful, please drop a reaction (❤️/🦄) belowit helps others find this guide!
I’d love to hear your thoughts:
Have you tried building multi-agent systems yet?
What tools are you using for your "Agentic" workflows?
Let’s discuss👇
Top comments (0)