Certifiedunder the Multi-Agent System module in the Mastering AI Agents program.Certifiedunder the Multi-Agent System module in the Mastering AI Agents program.This project presents a simple multi-agent travel planning system that automates key components of trip preparation. The system uses three lightweight agents—Budget Agent, Places Agent, and Itinerary Agent—coordinated using a LangGraph workflow. Each agent interacts with external tools such as geocoding, weather forecasting, place search, and routing APIs. The goal of this phase is to create a functional, end-to-end prototype capable of generating a basic travel itinerary for a given destination. All modules were developed using Python and free/open-source APIs, making the system accessible for learning and experimentation.
Travel planning typically requires gathering information from multiple sources, including weather data, attractions, routes, and estimated costs. This process can be time-consuming for users.
To address this, a multi-agent architecture was implemented where each agent focuses on a specific task:
Identifying relevant places and attractions
Calculating travel cost estimates
Generating a simple itinerary
The system demonstrates how separate agents can collaborate through a structured workflow.
#System Architecture
The proposed system follows a modular multi-agent architecture designed to automate travel planning through coordinated decision-making and task execution. The system consists of a central orchestration layer, a Planner Agent, multiple specialized Executor Agents, external tools, and a shared context mechanism.
User requests are first interpreted by the Planner Agent, which decomposes high-level travel goals into structured tasks. These tasks are distributed to specialized Executor Agents that interact with external tools such as search utilities, itinerary generators, and budget calculators. The orchestration framework ensures controlled task sequencing, error isolation, and efficient agent collaboration.
This architecture enables scalability, modularity, and clear separation of responsibilities while supporting real-world travel planning workflows.
The system operates in a structured workflow consisting of planning, execution, and aggregation phases. Upon receiving a user request, the Planner Agent analyzes the objective and produces a sequence of actionable tasks. These tasks are routed to the appropriate Executor Agents through the orchestration framework.
Executor Agents invoke relevant tools to complete assigned tasks and return intermediate results. The system aggregates these results into a coherent travel plan that is presented to the user. This workflow supports parallel execution where applicable and ensures efficient handling of multi-step travel planning scenarios.
A graph-based workflow coordinates the execution of each node in sequence:
Geocode Node – Converts destination text to coordinates
Weather Node – Fetches 7-day weather forecast
Places Node – Retrieves attractions, beaches, and food locations
Routing Node – Computes pairwise travel durations
Budget Node – Estimates overall trip cost
Itinerary Node – Generates a text-based travel plan using an LLM
Each agent is a focused module that interacts with external tools:
Budget Agent: Calculates flight, hotel, meal, sightseeing, and contingency estimates
Places Agent: Pulls places data from Geoapify
Itinerary Agent: Uses Groq LLM to produce a readable itinerary
Custom tools were implemented for:
Geocoding (Nominatim)
Weather forecasting (Open-Meteo)
Places search (Geoapify)
Routing matrix (OpenRouteService)
All tools use publicly available APIs and return structured data for downstream use.
#Agent Roles and Responsibilities
Each agent in the system is designed with a specialized role to ensure efficient task execution and maintainability.
Planner Agent
Responsible for interpreting user intent and decomposing complex travel goals into executable subtasks such as transportation selection, accommodation planning, and itinerary generation.
Executor Agents
Task-specific agents that perform concrete actions based on planner output. These agents handle operations such as searching destinations, estimating budgets, and generating travel schedules.
Tool Interface Layer
Acts as a bridge between agents and external services, enabling safe and controlled tool invocation.
This role-based separation improves system robustness and allows independent evolution of agent capabilities.
#Tools and Orchestration Framework
The system integrates multiple external tools to enhance agent capabilities and enable real-world interactions. These tools include destination search utilities, itinerary generation modules, and budget estimation components. Each tool is invoked dynamically based on task requirements, ensuring flexibility and extensibility.
An orchestration framework coordinates agent interactions, manages task dependencies, and enforces execution constraints. This design ensures reliable tool usage while preventing cascading failures across agents.
#Installation and Usage
Installation
The system can be executed locally with minimal setup requirements:
Python 3.10 or higher
Standard Python virtual environment
Required dependencies listed in requirements.txt
Steps:
Clone the repository
Create and activate a virtual environment
Install dependencies
Configure environment variables
Run the application
Usage
Users provide travel-related queries such as destination preferences, dates, and budget constraints. The system processes the input through its multi-agent pipeline and generates a structured travel plan.
To validate the system, several destinations were tested, with “Goa, India” used as the primary example.
Experiment Setup
Input: Destination = “Goa, India”
Default settings: 5 days, 1 person, mid-budget tier
APIs: Active and reachable during testing
Workflow executed from end to end via travel_planner.py
Checks Performed
Geocode returned valid coordinates
Weather node produced a 7-day forecast
Places node fetched 15 attractions, 15 beaches, 15 food spots
Routing node produced a valid matrix
Budget estimation completed without errors
Itinerary agent successfully returned structured text
The system produced the following outcomes:
Geocode: Correct latitude/longitude for Goa
Weather: 7-day forecast with temperature and rainfall data
Places: 45 total points of interest categorized into attractions, beaches, and food
Routing: Travel times computed between sampled locations
Budget: Total estimated cost within ±10% of realistic values
Itinerary: A structured 5-day travel plan generated by the LLM using the collected data
The end-to-end system generated an itinerary successfully, demonstrating proper coordination between all agents and tools.
This Phase 1 implementation successfully demonstrates a basic multi-agent travel planner using free APIs and a graph-based orchestration framework. While the system is simple, it validates the idea that multiple specialized agents can collaborate to generate a complete travel plan. Future phases may include more detailed budgeting, improved routing optimization, human-in-the-loop refinement, and UI integration. This work provides a foundation for experimenting with agentic AI concepts in a practical, real-world project.