Narasimha Kambham

Posted on Dec 10

Turning Exam Stress Into an AI Project: My AI Agents Intensive Experience

#googleaichallenge #ai #agents #devchallenge

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

If there’s one moment every student knows too well, it’s the night before an exam—when everything feels like it’s collapsing at once. I’ve had that moment more times than I’d like to admit: sitting at a desk cluttered with notes, jumping between panic and confusion, and quietly wishing for someone who could just help me sort out my thoughts.

Not another chatbot.
Not a generic answer dump.
But something that felt like a teammate—someone who understood the stress and helped me think clearly again.

Most LLMs never hit that mark for me. They responded, sure, but they didn’t feel the urgency. Sometimes they rambled, sometimes they hallucinated, sometimes they just missed the emotional tone entirely.

So when I joined the Google & Kaggle AI Agents Intensive, I hoped for at least one new idea… and ended up gaining much more.
This is the story behind my capstone project:
The Last-Minute Learning Copilot.

🧩 Before the Course — The Challenges I Kept Running Into

Even though AI always fascinated me, actually building agents felt like wrestling with a machine that refused to cooperate.

1. Boilerplate exhaustion

It felt like half my time went into plugging pieces together instead of building anything meaningful. Tools here, routes there, configs everywhere—it drained the excitement pretty fast.

2. Memory and session confusion

I never fully trusted whether the agent remembered what it was supposed to. Sometimes it held onto context, sometimes it forgot entirely. I didn’t want memorized rules—I wanted to understand why.

3. Deployment fear

Deployment was the stage I always postponed. One tiny mistake—an environment mismatch, a missing key—and everything blew up. It felt like walking into an exam without preparing. Terrifying.

4. Billing worries as a student

Many frameworks rely on API keys tied to credit cards. As someone without income—and with a family situation that doesn’t make these conversations easy—I always worried about:

random charges
rate limits
automatic renewals

It made experimentation stressful.

So when I saw “ADK” on the course schedule, my first reaction wasn’t excitement—it was:

“Oh no… another thing to struggle with.”

But I joined anyway. And thankfully, ADK turned out to be nothing like I expected.

🌟 Days 1–2: ADK Felt… Surprisingly Refreshing

The first two days gave me a completely different impression.

Instead of drowning in setup tasks, ADK actually lightened the load:

repetitive wiring disappeared
routing and memory were handled neatly
the structure made sense right away
I could finally focus on the logic, not the plumbing

It felt like someone built tools for the way my brain already wanted to work.
For the first time, building agents didn’t feel like a fight.

🧠 Day 3: The Big Wall — Memory vs Session

Then came Day 3, which was honestly the toughest part of the whole intensive.

Nothing behaved the way I expected:

sometimes the agent forgot context midway
sometimes tool calls changed everything
session state and memory state felt like identical twins I kept mixing up
I couldn’t tell where information was being stored

I replayed labs over and over, dug through discussions, and used run_debug so many times it felt like second nature.
At some point, the pieces finally connected—not as memorized definitions, but as a mental model.

After that moment, everything became clearer.

🧩 After That Breakthrough — Multi-Agent Systems Became… Fun?

Once I understood memory and sessions properly, the rest of the course opened up:

the router suddenly felt intuitive
tools started behaving consistently
google_search stopped acting unpredictable
the ParallelAgent no longer scared me
debugging transformed into actual reasoning
the architecture made sense as a whole

It was the first time I genuinely felt capable of building a proper multi-agent system instead of forcing one together.

🏗️ My Capstone Project — The Last-Minute Learning Copilot

This project came straight from my lived experience as a student.

It’s designed to be more than an answer bot.
It tries to be a mentor that can:

notice confusion
sense urgency
calm stress
explain concepts clearly
build realistic study plans
use tools intelligently
combine everything into one grounded response

Here’s what’s happening behind the scenes:

🧠 Multi-Agent Architecture Overview

🔹 RouterAgent

Decides which part of the system should take over:

concept questions → ExplanationAgent
planning → StudyPlannerAgent
emotional or conceptual struggle → StressAgent + WeakTopicAgent
fallback for unclear intents

🔹 StudyPlannerAgent

Checks the time and builds a realistic schedule—crucial during last-minute prep.

🔹 StressAgent + WeakTopicAgent

These run together and help detect:

emotional stress
misunderstanding
weak areas that need revision

It works a bit like having two tutors observing you simultaneously.

🔹 ExplanationAgent

Structured explanations, grounded facts, and a google_search call only when necessary.
I put some guardrails in place so it wouldn’t drift into fantasy mode.

🔹 OrchestratorAgent

This agent honestly felt like the heart of the whole setup.
It was the glue—taking all the scattered outputs and turning them into one supportive, understandable message.

The whole architecture felt like building a small team of specialists who each step in when their skill is needed.

🎬 Adding Creativity — The Video That Brought Everything Together

One part I didn’t expect to enjoy so much was creating the video that showcased this system.

I wanted students to feel the story behind it, not just read about it. So I:

🎙️ recorded my own voice-over
🎨 added cartoon-styled sketches
🎞️ opened with a short emotional scene
🎵 chose music that matched the tone

It helped me show the human side of the project, not just the technical one.

🎉 The Moment Everything Finally Worked

I still remember the first clean, perfect run:

the router picked the right paths
the planner generated a realistic study plan
the stress agent responded calmly
the explanation agent fetched accurate info
the orchestrator wrapped everything into one coherent answer

For the first time, it didn’t feel like pieces glued together.
It felt like a living system.

That moment showed me just how far I’d come in a single week.

🧭 How the Course Changed My Understanding of Agents

Before the course, I thought:

“Agents are just chatbots with extra responsibilities.”

But the more I built, the more I realized agents are about:

decision flow
modular thinking
delegation
state and memory
tool-augmented intelligence

It shifted how I think about AI systems entirely—from prompt engineering to actual system design.

💡 What I’m Taking Away From This Experience

Here are the lessons that stuck with me:

ADK removes so much of the friction I used to struggle with
memory and session design are critical to get right
multi-agent setups solve problems one model alone can’t
and if I had to highlight one unsung hero: run_debug is basically a flashlight in a dark tunnel
adding creative storytelling truly elevates a technical project
real problems make the best project ideas

🌱 Personal Growth

This intensive pushed me to grow in multiple ways:

I became more confident as an AI engineer
I gained a clearer design mindset
I learned to mix creativity with technical work
and I feel more aligned with the direction I want to take in AI

The Last-Minute Learning Copilot isn’t just a project—it’s something I genuinely wish existed when I needed it most.

🧪 Quick Note on My Kaggle Notebook

If you want to see the actual code behind this project, I’ve documented everything in my Kaggle notebook — from the early routing tests to the final multi-agent flow.

Here’s the link:
👀 Look Inside the Machine Room

It’s basically the full build process in one place.
If you notice anything I could improve — cleaner routing, better memory handling, or tool setup suggestions — I’m more than open to feedback.