Intelligent Multi-Agent Trip Planning System

Arun Somu-Panneerselvam — Sun, 14 Dec 2025 16:08:22 +0000

Building iPathPilot: From AI Agent Theory to a Multi-Agent System

My Learning Journey / Project Overview

The AI Agents Intensive fundamentally reshaped how I think about building intelligent systems. Prior to the course, I viewed LLM-based solutions largely as model-centric pipelines. The course made one thing very clear:

Agents are systems, not models.

To internalize this shift, I built iPathPilot – an Intelligent Multi-Agent Trip Planning System, a fullstack application that demonstrates how autonomous agents can collaboratively reason, plan, act, and observe in the real world.

iPathPilot solves a practical problem:

End-to-end trip planning with route optimization, POI discovery, cost estimation, and environmental impact analysis—delivered through a coordinated team of AI agents.

The system leverages:

Google Agent Development Kit (ADK)
Gemini 2.5 models
Google Maps & Routes APIs
Server-Sent Events (SSE) for real-time agent observability

Rather than building a single “do-everything” agent, I intentionally designed a 7-agent sequential pipeline, mirroring real-world organizational workflows.

GitHub Repository: 👉 https://github.com/aiscalelearn/iPathPilot
Kaggle : https://kaggle.com/competitions/agents-intensive-capstone-project/writeups/new-writeup-1764370781160

Key Concepts / Technical Deep Dive

1. From Monolithic Prompts to Collaborative Agents

One of the most impactful concepts from the course was multi-agent system design.

In iPathPilot, each agent has:

A single responsibility
Clear inputs and outputs
Explicit tool access
No hidden side effects

The pipeline looks like this:

Prompt Capture Agent – Preserves raw user intent (no mutation)
Router Agent – Calls Google Routes API (traffic-aware, waypoint optimization)
Planner Agent – Converts raw route data into human-readable navigation
Optimizer Agent – Identifies traffic, toll, and detour optimizations
POI Finder Agent – Discovers hotels, restaurants, attractions, fuel stations
Cost Calculator Agent – Estimates fuel cost and CO₂ emissions
Summarizer Agent – Produces a clean, structured, frontend-safe response

This architecture directly reflects Level 3: Collaborative Multi-Agent Systems, where agents treat other agents as tools rather than competitors.

2. Tool Use Is Where Agents Become “Real”

The course reinforced that tools are an agent’s hands.

In iPathPilot:

The Router Agent uses compute_routes() via Google Routes API

The POI Finder Agent uses Google Search grounding

The Summarizer Agent invokes a custom tool:

clean_and_format_route_response()

This function was critical. It:

Extracts encoded polylines
Removes control characters (0x00–0x1F, 0x7F)
Produces JSON-safe structured output
Wraps results in markdown for reliable frontend parsing

This directly applied the course principle:

Publish tasks, not APIs.

The agent never reasons about how sanitization works—only when it’s needed.

3. Observability Is Not Optional for Agents

One of the strongest lessons from the Agent Quality and Prototype-to-Production modules was:

You cannot evaluate what you cannot observe.

iPathPilot was designed with observability from day one:

Server-Sent Events (SSE) stream each agent’s progress
Frontend displays:
- Agent transitions
- Tool calls
- Intermediate reasoning stages
The final response is assembled only after all agents complete successfully

This aligns with:

Trajectory-based evaluation
Process visibility over final-output-only judgment

Debugging issues like “Why didn’t the polyline render?” became trivial because the agent trajectory was fully visible.

4. Agent Quality Over “It Works”

The course reframed quality as a continuous loop, not a test case.

In iPathPilot, quality is evaluated across four dimensions:

Effectiveness – Did the plan match user intent?
Efficiency – Were unnecessary agent steps avoided?
Robustness – Did the system degrade gracefully on API failures?
Safety – Are outputs sanitized and frontend-safe?

This thinking influenced:

Defensive API error handling
Polyline sanitization
Explicit agent instructions (e.g., “MUST call tool X”)

The biggest mindset shift:

An agent that “eventually works” can be improved a lot.

5. From Prototype to Production Mindset

iPathPilot is not a demo -- it is deployable.

Key production considerations baked in:

Cloud Run & Vertex AI Agent Engine deployment
Environment-based configuration
Optional AgentOps tracing
Secure API key handling
Frontend-backend contract enforcement

The course made it clear that 80% of the work happens after the agent is “intelligent enough.”

Reflections & Takeaways

What resonated most?

Agents are autonomous systems, not enhanced prompts
Observability is foundational, not an afterthought
Tool design and documentation matter more than prompt cleverness
Evaluation must focus on behavior and trajectory, not just answers

How has my understanding evolved?

I moved from:

“How do I get the model to respond correctly?”

to:

“How do I design a system that reasons, acts, fails safely, and improves?”

What I would do differently next time

Introduce parallel agent execution earlier
Add RAG + MCP from day one
Build automated evaluation gates into CI/CD

Final Thoughts

Building iPathPilot transformed abstract agent concepts into concrete engineering practice.
The AI Agents Intensive didn’t just teach how agents work—it taught

> how to trust them in production

If you’re transitioning from LLM demos to real-world systems, my biggest advice is this:

Design agents like you design teams: with clear roles, visibility, accountability, and trust.

If you’d like to explore the project or extend it (bookings, voice AI, group travel, or enterprise logistics), check out the repository and feel free to contribute.

Happy building in the agentic era.

Youtube Playlist:

Demo - https://youtu.be/6BA2TPzNxmk?si=HFsHhCBr4h44Nfbr
Flow - https://youtu.be/8A5CRxT71lE?si=GC609cEt0UXmeM-7
Inside AI - https://youtu.be/8T8_HvRAd5A?si=2wii6uU6ID1vne8d
Agent Ops - https://youtu.be/H1F6xRf-ous?si=ZN-OOZah0sMtkl-U

DEV Community: Arun Somu-Panneerselvam

Intelligent Multi-Agent Trip Planning System

My Learning Journey / Project Overview