Transforming Travel Planning: From Bottleneck to Streamlined Multi-Agent System

Introduction to Agent Collaboration in Travel Planning

Solution Overview: A Multi-Agent Approach

Implementation Overview of the Travel Planning System

Travel Agent Implementation Using Amazon Nova 2 Lite

Flight Agent Implementation for Structured Data Retrieval

Hotel Agent Implementation for Navigating Dynamic Content

A2A Message Flow: Facilitating Agent Communication

End-to-End Example Run of the Travel Planning Process

Conclusion: The Benefits of a Multi-Agent Design

About the Authors

Transforming Travel Planning: From Single-Agent Chaos to Multi-Agent Harmony

When I first embarked on building a travel planning agent, I envisioned a streamlined solution consisting of one large model, a handful of tools, and an extensive system prompt. It performed admirably—right up until I threw real-world complexity into the mix. The clean API for flight details contrasted starkly with the chaotic hotel search process hidden behind fluid web interfaces. The result? A single-agent setup became a bottleneck, tangled in confused instructions and lost contexts, a situation that demanded a radical redesign.

Solution Overview

The breakthrough came with the realization that my approach needed to change. Instead of attempting to improve the single agent through complex prompts, I opted to distribute tasks among specialized agents. This post describes the implementation of agent-to-agent collaboration on Amazon Bedrock, using Amazon Nova 2 Lite for planning tasks and Amazon Nova Act for browser interactions. The outcome was a robust multi-agent system that made the process both predictable and efficient.

Multi-Agent Architecture

The restructured system comprises a small team of agents, each entrusted with specific responsibilities. The Travel Agent interacts directly with the user, planning the trip, while the Flight and Hotel Agents focus on their specialized tasks—finding flight options and navigating hotel listings, respectively. This division of labor allows each agent to concentrate on what they do best, facilitating a seamless experience for the user.

The initial prototype struggled not because the tasks were inherently difficult, but because they were inherently distinct. Searching for flights involves structured and predictable data, while hotel searches often require navigating messy, dynamic web pages full of fluctuating elements. Asking a single agent to juggle both task types was akin to a developer being asked to simultaneously write backend code and perform live debugging on a front-end application. The overload of responsibility led to errors, inconsistencies, and ultimately, a system that could not sustain its own design. The solution lay in separating these tasks across three dedicated agents while maintaining coherence through a simple messaging framework.

Implementation Overview

With the architecture established, it was time to build the multi-agent system. The Travel Agent and Flight Agent utilize Amazon Nova 2 Lite for their reasoning and planning capabilities, while the Hotel Agent relies on Amazon Nova Act for browser automation when APIs are unavailable. Agents communicate using straightforward messages, ensuring that the workflow remains predictable even when each agent operates within different environments.

Travel Agent Implementation (Amazon Nova 2 Lite)

The orchestration of the workflow resides with the Travel Agent. This agent accepts user requests, interprets the intent using Nova 2 Lite, and delegates tasks to the appropriate agents. By focusing solely on reasoning and planning, the Travel Agent maintains clarity in its messaging without overwhelming itself with external system interactions.

Here’s a simplified version of the Travel Agent’s initialization code:

# Initialize A2A client tools
provider = A2AClientToolProvider(known_agent_urls=[
    "http://localhost:9000",  # Hotel Booking Expert (Nova Act)
    "http://localhost:9001"   # Flight Booking Expert
])
bedrock_model = BedrockModel(
    model_id="global.amazon.nova-2-lite-v1:0",
    region_name="us-east-1",
)

# Create client agent with A2A tools
client_agent = Agent(
    name="Travel Client",
    model=bedrock_model,
    description="Client agent that coordinates travel planning using specialized A2A agents",
    tools=provider.tools,
    system_prompt="""You are an autonomous travel planning agent. You MUST take action immediately without asking for confirmation.
)

When a user requests a trip, the Travel Agent intelligently breaks down the request into manageable tasks—communicating with the Flight Agent for data on flights and then triggering the Hotel Agent for accommodation options. This approach maintains clean orchestration and allows each agent to focus on their respective tasks.

Flight Agent Implementation (Amazon Nova 2 Lite and API)

The Flight Agent’s role is straightforward: it converts structured input into actual flight options. Employing Amazon Nova 2 Lite, it handles input validation, formats the search request, and interacts with the live flight API (when available) to fetch data. Following the request, it returns the data back to the Travel Agent in a clean and structured format.

Here’s a simplified function for the flight search:

@tool
def search_flights(origin: str, destination: str, departure_date: str, return_date: Optional[str] = None) -> str:
    # Nova 2 Lite handles the reasoning around which path to take
    if amadeus_configured():
        return _search_amadeus_flights(
            origin=origin,
            destination=destination,
            departure_date=departure_date,
            return_date=return_date
        )
    else:
        # Local development fallback
        return _search_flights_web(origin, destination, departure_date, return_date)

The response includes structured flight data, ensuring reliability and clarity for the Travel Agent’s use.

Hotel Agent Implementation (Amazon Nova Act)

Unlike the straightforward data provided by flight APIs, hotels are far more unpredictable. They are often accessed through shifting website layouts, robustly designed to inhibit automated scraping. The Hotel Agent, utilizing Amazon Nova Act, circumvents this by controlling a real browser to execute natural language instructions for hotel searches, delivering structured data in return.

Here’s a brief view of the hotel search function:

@tool
def search_hotels(location: str, checkin_date: str, nights: int = 2) -> str:
    with NovaAct() as nova:
        result = nova.act(
            f"Search for hotels in {location} from {checkin_date} for {nights} nights. "
            f"Return the top 3 listings with name, price, and rating.",
            schema=HotelSearchResults.model_json_schema()
        )
        return json.dumps(result)

When the Hotel Agent finds the necessary hotel data, it systematically sends it back to the Travel Agent.

A2A Message Flow

Communication between agents occurs through a structured message-passing framework. Before initiating tasks, the Travel Agent checks the operational status of the other agents and discovers the capabilities available through their endpoints. The workflow is simple: the Travel Agent sends a request to the Flight Agent, retrieves flight options, sends hotel requests to the Hotel Agent, and finally gathers everything into one coherent response for the user.

End-to-End Example Run

To illustrate this system, consider the following user request:

“Please arrange travel for one person from NYC to Paris on December 6, 2025, including a two-night stay in Paris.”

1. Travel Agent → Flight Agent: The Travel Agent extracts the flight details and requests available flights from the Flight Agent.
2. Flight Agent Response: The Flight Agent provides three affordable flight options, detailing airline, times, price, and duration.
3. Travel Agent → Hotel Agent: The Travel Agent then sends a request for hotel accommodations to the Hotel Agent.
4. Hotel Agent Response: The Hotel Agent returns top hotel selections, including names, prices, and brief descriptions.
5. Final Response to User: The Travel Agent consolidates and presents the complete travel plan to the user, which includes suggested flights, hotel accommodation details, and a prompt for booking.

Conclusion

The transition from a single-agent design to a multi-agent architecture revolutionized the travel planning process. Each agent now excels in its designated role, and communications between them are clean and efficient. This modular setup not only streamlines the process but also enhances the system’s robustness against unforeseen complexities.

This architecture can be applied beyond travel—it’s a model for any task that involves diverse skillsets and complexities. By allowing dedicated agents to handle specific responsibilities, we create systems that are easier to maintain, adapt to changes, and explain to users.

For those interested in exploring this implementation further, complete code and examples can be found in the Agent to Agent with Amazon Nova GitHub repository.

About the Authors

Yoav Fishman is an AWS Solutions Architect with over a decade of experience in the cloud and engineering sectors. Specializing in GenAI, Agentic AI, and cybersecurity, he assists startups in building scalable architectures that deliver significant business impact.

Elior Farajpur is a passionate Solutions Architect at AWS, dedicated to designing innovative cloud-based solutions that drive true business value.

Dan Kolodny, another expert in AWS architecture, focuses on big data, analytics, and GenAI, helping organizations adopt best practices and leverage insights from their data.