OptimaWave AgentAI Travel Planner

Bharat Bika — Sat, 13 Dec 2025 04:28:55 +0000

AI Agents Intensive Course Writing Challenge https://dev.to/challenges/google-kaggle-ai-agents-2025-11-10

OptimaWave Agent: How the 5 Day AI Agents Intensive Course Helped Me Build a Smarter Travel Planner

Your Budget. Your Trip. Designed by AI.

Introduction

The Google x Kaggle 5 Day AI Agents Intensive Course was a turning point in my AI journey.
Before this course, I understood LLMs but did not fully grasp agents systems that observe, reason, plan, act, and work autonomously.

Over five days, through whitepapers, codelabs, and hands on experimentation, I learned to design real agentic systems using:

ADK (Agent Development Kit)

LLM (Large Language Model)

Model Context Protocol (MCP)

Context Engineering

Observability Tools

Agent2Agent (A2A) Protocol

Vertex AI Agent Engine

To apply this knowledge, I built OptimaWave Agent, an AI powered travel planner that recommends destinations based on budget, travel days, and theme.

This article is the story of how each day of the course shaped my understanding and inspired my final capstone project.

Day Wise Learnings (Full Reflection)
Day 1: Introduction to Agents

Understanding what makes agents different from LLMs.

I learned:

Agents are autonomous beings with goals

Tools enable actions beyond text

Multi agent collaboration solves complex tasks

Interoperability and identity control are core to security

Agent Ops is essential for reliability and governance

I built my first agent using ADK + Gemini, and even created a small multi agent system.
This inspired OptimaWave Agent’s modular architecture.

Day 2: Agent Tools & Model Context Protocol (MCP)

Day 2 showed me that tools turn LLMs into agents.

Key learnings:

Convert Python functions into agent tools

Extend agent capabilities beyond training data

Pause resume agent operations

Simplify tool discovery with MCP

For OptimaWave Agent, this inspired:

Filtering tools

Ranking tools

Dataset exploration tools

Visualization tools

Day 3: Context Engineering: Sessions & Memory

Agents must remember and maintain context.

I learned:

Use session history to maintain coherent conversations

Build long term memory across sessions

Dynamically assemble context for reasoning

In OptimaWave Agent, this allows the planner to:

Track user preferences

Refine recommendations over time

Maintain state across multiple turns

Day 4: Agent Quality (Logs, Traces, Metrics)

Making agents reliable, observable, and trustworthy.

Key learnings:

Logs: What happened

Traces: Why it happened

Metrics: How well it happened

In my planner, observability helps answer:

Why a destination was filtered out

Why a theme was recommended

How cities were ranked

Day 5: Prototype to Production

Deploying and scaling real agentic systems.

I learned:

Production lifecycle of agents

Deployment on Vertex AI Agent Engine

Scaling strategies

Multi agent collaboration using A2A Protocol

This inspired a multi agent travel system:

One agent for destinations

One for hotels

One for flights

One for weather

One for budgeting

Capstone Project: OptimaWave AgentAI Travel Planner

Problem:
Travelers struggle to balance:

Budget

Number of days

Destinations

Themes (romantic, adventure, heritage, etc.)

Planning is stressful, slow, and manual.

Solution:
An AI agent that instantly recommends the best destinations fitting user constraints.

Core Features:

Budget based filtering

Theme matching

Travel day optimization

Dynamic destination ranking

Visualization of available options

Interactive Kaggle Notebook demonstration

Example Input Output (Corrected)

Input:

Budget: 1300 USD

Days: 5

Theme: Romantic

Output:

Destination Travel Days Theme
Paris 5 romantic
Dubai 4 luxury
London 5 heritage

Visualization:

Bar chart showing budget comparisons across all destinations:

Dubai: 1000

Paris: 1200

London: 1300

Tokyo: 1500

Sydney: 1800

Architecture (Inspired by Day 1 & 5 Learnings)
User Input

Agent Processor (ADK + LLM)

Filtering Tools (Day 2)

Context Engine (Day 3)

Observability Pipeline (Day 4)

Recommendation Engine

Output + Visualization

This is a course aligned, production ready architecture.

Tools Used

ADK (Agent Development Kit)

LLM (Large Language Model)

Google AI Studio

MCP

Python

Kaggle Notebook

CSV Dataset

Future Improvements (Inspired by Day 5)

Multi agent travel ecosystem (A2A)

Live APIs: flights, hotels, weather

Personal itinerary generator

User preference memory

Only the Planner Module has been developed (Future version: Web + App support)

Full deployment on Vertex AI Agent Engine

Final Reflection

This intensive course didn’t just teach me how to build agents it taught me how to think in agents.

Every day built a new layer of understanding:

Day 1: What agents truly are

Day 2: How they act

Day 3: How they remember

Day 4: How we evaluate them

Day 5: How we deploy them

OptimaWave Agent is the result of this 5 day journey a fully working structured intelligent AI travel planner.

This challenge helped me grow from an intermediate ML developer to an advanced agentic system builder.

OptimaWave AgentAI End to End Code Implementation & Output Demonstration:

This version improves reliability by adding schema based validation before agent tool execution to prevent free form LLM errors:

Forem: Bharat Bika

OptimaWave AgentAI Travel Planner