🧠 From Prompts(where almost everyone starts with LLMs) to Autonomous Teams(where agentic systems live)

Umadevi R — Sat, 13 Dec 2025 14:23:38 +0000

My Journey Through the Google & Kaggle AI Agents Intensive

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

Why I Signed Up

I had worked with large language models before this course—writing prompts, refining outputs, and integrating them into applications. But something always felt incomplete.

The 5-Day AI Agents Intensive by Google and Kaggle promised to answer a question I kept coming back to:

How do we move from a single intelligent response to systems that can think, act, remember, and collaborate?

By the end of the course, I wasn’t just building AI-powered apps anymore—I was designing agentic systems.

Day 1: Introduction to Agents — A Mental Model Shift

Day one fundamentally changed how I think about AI.

Instead of viewing LLMs as enhanced chatbots, the course introduced AI agents as autonomous entities with goals, decision-making ability, and the capacity to operate within a system.

What stood out most was understanding how agentic architectures differ from traditional LLM applications.

Agents are not just invoked—they act.

This laid the groundwork for everything that followed.

Day 2: Agent Tools & Interoperability with MCP

Day two focused on how agents interact with the world through tools.

We explored how AI agents can take real actions by leveraging external APIs and services, and how the Model Context Protocol (MCP) simplifies tool discovery and interoperability.

Key learnings:

Tools transform agents from responders into actors
MCP reduces integration complexity
Standardized tool access improves scalability and safety

This shifted my mindset from “LLMs that know things” to agents that do things responsibly.

Day 3: Context Engineering — Sessions & Memory

This day had the biggest impact on my thinking.

We learned how to design agents that:

Maintain short-term session context
Persist long-term memory
Handle complex, multi-turn interactions

The key realization:

Memory is not an enhancement—it’s a requirement.

An agent without memory can answer.
An agent with memory can support, adapt, and evolve.

Day 4: Agent Quality — Reliability Over Brilliance

Day four focused on building trustworthy agents.

Topics included:

Observability
Logging and tracing
Evaluation metrics
Performance monitoring

One insight stood out clearly:

A reliable agent is more valuable than a clever one.

Understanding agent behavior through evaluation and tracing is essential—especially in multi-agent systems.

Day 5: Prototype to Production — Thinking Beyond Demos

The final day bridged experimentation and real-world deployment.

We learned best practices for:

Deploying and scaling agents
Moving beyond local testing
Building truly multi-agent systems
Coordinating agents using the Agent2Agent (A2A) Protocol

This reinforced that production-grade agents require clear boundaries, communication standards, and coordination mechanisms.

Capstone Project: SerenitySphere

All of these learnings came together in my capstone project:

🎥 Demo Video

A short walkthrough of SerenitySphere, demonstrating how multiple AI agents collaborate to provide emotionally safe, structured support.

👉 SerenitySphere – A Multi-Agent Emotional Healing Companion

https://www.kaggle.com/competitions/agents-intensive-capstone-project/writeups/serenitysphere-multi-agent-emotional-healing-c

SerenitySphere is a multi-agent system where each agent has a focused responsibility:

One agent listens and understands emotional context
Another reflects and reframes emotions
Another provides grounding and coping strategies

Instead of a single overloaded model, the system relies on collaboration, memory, and structured workflows—directly inspired by the course.

How My Understanding of AI Agents Evolved

Before this course:

Agents felt abstract
Multi-agent systems felt fragile

After this course:

Agents feel architectural
Multi-agent systems feel intentional
Tools, memory, and protocols feel foundational

I no longer see agents as smart prompts.

I see them as software systems with behavior.

What I’m Taking Forward

This course reshaped how I approach AI system design:

Design agents with clear roles
Treat memory as a first-class concept
Prioritize observability and evaluation
Optimize for reliability over novelty
Think in systems, not responses

Final Reflection

The Google & Kaggle AI Agents Intensive didn’t just teach me how to build agents—it taught me how to think like an agent architect.

SerenitySphere exists because of that shift.

This feels like just the beginning.

Helpful Links & Resources

AI Agents Intensive Course: https://www.kaggle.com/learn-guide/5-day-agents
Kaggle Discord: https://discord.gg/E5QXE8Xm
SerenitySphere Capstone: https://www.kaggle.com/competitions/agents-intensive-capstone-project/writeups/serenitysphere-multi-agent-emotional-healing-c

DEV Community: Umadevi R