Forem: Mahesh Jagtap

My Learning Reflections : Kaggle’s 5-Day AI Agents Intensive with Google

Mahesh Jagtap — Mon, 15 Dec 2025 07:59:29 +0000

Google AI Challenge Submission

This is a submission for the Google AI Agents Writing Challenge: Learning Reflections

🔎Introduction

Kaggle’s 5-day AI Agents Intensive reshaped how I think about building with large language models—from prompting single responses to designing systems that act, reason, and collaborate over time.

🌟 Key Learnings & Concepts That Resonated

1. Agents are workflows, not prompts
The biggest shift for me was realizing that effective agents are less about clever prompts and more about orchestration: state, memory, tools, feedback loops, and evaluation. Prompting is just the interface; the real power comes from how components are wired together.

2. Tool use unlocks real-world impact
Seeing agents call tools—search, code execution, APIs, databases—made it clear how LLMs move from “chatbots” to operators. Tool selection, schema design, and error handling became first-class concerns.

3. Planning, reflection, and iteration matter
Patterns like plan → act → observe → reflect stood out. Agents that pause to evaluate intermediate results consistently outperform those that rush to an answer. Reflection isn’t fluff—it’s a performance multiplier.

4. Multi-agent systems amplify capability (and complexity)
Having specialized agents (planner, researcher, critic, executor) collaborate showed how decomposition improves outcomes. At the same time, it highlighted new challenges: coordination overhead, cost, and failure modes.

5. Evaluation is hard—but essential
Agentic systems can fail silently. The course emphasized lightweight evals, guardrails, and logging to catch errors early. Measuring success goes beyond accuracy to include robustness, latency, and cost.

🔄 How My Understanding of AI Agents Evolved

Before the course, I thought of agents as “LLMs with tools.” After the intensive, I see them as software systems powered by LLM reasoning. The mindset shift was from prompt engineering to systems engineering:

From single-turn answers → multi-step reasoning
From static responses → adaptive behavior
From monolithic models → modular, composable agents

This reframing made agent design feel closer to building distributed systems—just with language as the control plane.

Multi-Agent Customer Support Assistant — Capstone Project Overview 🏆

This project implements a simple but fully functional Multi-Agent Customer Support Assistant built for the Enterprise Agents track.
The purpose of this system is to demonstrate how multiple specialized agents can work together to automate a real business workflow—in this case, handling customer messages in a support environment.
Although the agents are lightweight and rule-based, the architecture clearly represents how multi-agent frameworks operate in enterprise settings: through specialization, coordination, and automated decision-making.

🎬Capstone Project Hackathon Writeup✍🏻

Capstone Project Hackathon Writeup

☎️What This System Does🌈

When a user sends a message (like “I need a refund” or “My invoice amount is wrong”), the system processes it using three different agents, each responsible for a specific task:

1.Intent Agent (Understands the Customer’s Message)

This agent analyzes the message and identifies its intent (refund, cancellation, billing issue, etc.) and urgency level (low, medium, high).
Even with simple rules, this agent demonstrates classification, routing, and task identification—core elements of enterprise automation.

2.Reply Agent(Generates a Professional Response)

Once the intent is identified, the Reply Agent produces a short, clean, professional customer support reply.
This simulates how enterprises use AI to draft emails, chat responses, and automated replies for customer tickets.

3. Escalation Agent (Decides When Human Support Is Needed)

Not every customer message can be solved automatically.
This agent checks urgency and intent, and determines whether the issue requires escalation to a human support agent.
It produces escalation notes and reasons—mirroring how real businesses prioritize and triage tickets.

4. Coordinator Agent (The “Brain” of the System)

The Coordinator receives the message, calls the three specialized agents, collects their outputs, and returns a complete response package containing:

The predicted intent

The urgency level

The auto-generated reply

The escalation decision

A clean JSON output

This shows how multi-agent systems rely on orchestration, not just isolated decision-making.

Why I Built This Project❔

For the Enterprise Agents track, Kaggle requires the demonstration of multi-agent collaboration applied to a business problem.
I chose customer support automation because:

1. It is a real and common enterprise workflow

Companies receive thousands of customer tickets every day.
Automating the first layer of classification and response can save businesses a lot of time.

2. Easy to understand and demonstrate

Agents in this notebook have clear responsibilities and predictable outputs.
Judges and users can easily see how each agent contributes to the final answer.

3. A perfect fit for multi-agent architecture

Customer support naturally splits into:

Understanding the message

Generating a reply

Making escalation decisions

This makes it ideal for demonstrating agent specialization.

4. Lightweight but practical

The project uses simple rule-based logic instead of heavy models, making it:

Fast to run

Easy to understand

Safe to execute without external API calls

But the structure is extensible—LLMs can replace each agent for more advanced versions.

5. Meets all Kaggle agent competition requirements

📺 Project Overview Video🎬(2 minutes)

Project Overview Video

🔑What I learned✅ :

Clear role boundaries dramatically improve output quality
Naive agent loops can explode in cost without stop conditions
Even simple reflection steps can catch hallucinations early

Most importantly, I learned that simplicity wins: the best gains came from thoughtful structure, not adding more agents.

💡 Final Takeaways💯

This intensive sharpened both my technical skills and my intuition. Agentic AI isn’t magic—it’s careful design, iteration, and evaluation. But when done right, it unlocks a powerful new way to build intelligent systems that think in steps, use tools, and work together.

I’m leaving the course excited to keep experimenting—pushing from simple agents toward robust, production-ready multi-agent systems.

🔎 Conclusion

The Google🌈 & Kaggle Intensive was a masterclass not just in coding, but in thinking.

Building agents is not just about chaining prompts; it is about designing resilient systems that can handle the messiness of the real world.

Evaluation ensures we trust the process, not just the result.
Dual-Layer Memory solves the economic and context limits of LLMs.
Protocol-First (MCP) prevents integration spaghetti and silos.
Resumability allows agents to participate in human-speed workflows safely.

📎Appendix
Kaggle Notebook

A huge thank you🙏 to the Google and Kaggle teams for putting this together. I highly recommend these materials to any developer or architect serious about building the next generation of AI.

From User to Builder : My Honest Learning Reflections from Kaggle’s 5-Day AI Agents Intensive Course with Google

Mahesh Jagtap — Fri, 12 Dec 2025 14:58:26 +0000

This is a submission for the Google AI Agents Writing Challenge: Learning Reflections

💡Introduction

Over the past five days, I immersed myself in Google and Kaggle’s AI Agents Intensive, a hands-on learning sprint designed to help participants understand, build, and deploy AI agents using practical tools and real-world challenges. What began as curiosity quickly evolved into a structured, insightful journey into the future of intelligent automation.

🌱 Day 1 — Foundations of AI Agents

The program kicked off with the core concepts: What are AI agents? How do they perceive, reason, and act?
I explored agent architectures, from simple reactive designs to more advanced planning-based models. The highlight of the day was experimenting with pre-built agents on Kaggle and observing how they handled tasks autonomously. It was the first moment I realized how transformative agent-driven workflows can be.

🛠️ Day 2 — Tools, Frameworks & Notebook Walkthroughs

This day focused on the practical ecosystem behind AI agents.
I learned how to use Kaggle's notebook environment, integrated APIs, and Google’s developer tools to set up the scaffolding for agent experiments.
Hands-on exercises included:

interacting with agent toolsets
modifying simple agent behaviors
experimenting with prompt engineering for task optimization

It was my first real taste of building—not just learning.

🤖 Day 3 — Building My First Agent

This was the breakthrough moment.
I built a functional AI agent capable of performing a multi-step task on its own.
I learned how to:

define agent goals
provide tools and constraints
evaluate the agent’s reasoning trace
refine its behavior through iterative feedback

Seeing my agent complete tasks end-to-end felt incredibly rewarding.

🚀 Day 4 — Advanced Agent Workflows & Optimization

On Day 4, we went deeper.
The focus shifted to agent robustness: How do you make an agent reliable? Efficient? Safe?
I explored techniques such as:

chaining tools
adding memory and state
improving reasoning patterns
using evaluation benchmarks from Kaggle

This day challenged me to think like a system designer, not just a user.

💡Day 5: Responsible AI & Future Trends🌈

The final day focused on responsible AI principles, including fairness, transparency, privacy, and safety. Discussions about future trends—such as more personalized AI, agent-based systems, and tighter human-AI collaboration—helped me see where the field is heading.

Key takeaway: Responsible design will define the long-term success of Generative AI.

🏁 Capstone Challenge & Reflection⚡

The final day culminated in a mini-project: create an agent capable of solving a realistic problem with minimal intervention.
My agent wasn’t perfect, but it worked—and the process taught me more than success alone ever could.

This journey changed the way I think about AI:
It’s not just about models or prompts anymore. It’s about autonomous, goal-driven systems that can collaborate with humans to streamline tasks, explore data, and solve meaningful problems.

🌟 What I’m Taking Away

AI agents are the next major step in everyday AI applications.
Even beginners can build functional agents with the right tools.
Experimentation is the fastest way to understand how these systems think.
The future of work will be shaped by human–agent collaboration.

🏆Multi-Agent Customer Support Assistant — Capstone Project Overview