Google and Kaggle Release Free 5-Day Agentic AI Intensive Course for Developers

As the artificial intelligence landscape shifts rapidly from simple single-turn prompts to autonomous systems capable of complex decision-making, educational resources are evolving to meet the demand. To help developers bridge this gap, Kaggle and Google have made their comprehensive "5-Day AI Agents Intensive Course" available as a free, self-paced learning program. Originally broadcast live from November 10 to 14, 2025, the curriculum offers an in-depth exploration of how AI agents function, how they are architected, and what it takes to transition them from experimental notebook environments into production-grade deployments.

The transition from a standard large language model application to an agentic system represents a fundamental shift in software design. While a single prompt and a single response are relatively straightforward to reason about, an agent introduces a continuous operational loop. In this environment, the model dynamically selects an action, invokes an external tool, reads the resulting output, and determines the subsequent step. This architectural loop introduces a host of operational challenges that one-shot API calls never encounter, such as managing conversational state across multiple turns, validating tool selection accuracy, and ensuring reliable execution outside of local development notebooks.

Designed to address these exact hurdles, the curriculum pairs theoretical whitepapers with hands-on coding notebooks built around Google’s Gemini models and the Agent Development Kit (ADK), an open-source framework specifically engineered for building agents. While participants are expected to have a foundational understanding of Python and some prior experience calling large language model APIs, the program assumes no prior knowledge of agentic workflows, making it an accessible entry point for engineers looking to expand their skill sets.

Building a First Agent and Wiring Several Together

The foundational module of the course introduces the core concepts of agentic systems and the diverse architectures possible using the Agent Development Kit. Through its initial components, developers learn how to construct a basic operational agent before scaling up to multi-agent ecosystems where several distinct entities collaborate to solve complex problems.

Within the ADK framework, an agent is treated as a modular bundle comprising a specific identifier, an underlying language model, a functional description readable by peer agents, behavioral instruction prompts, and an authorized list of tools. Execution of these components is handled by a runner, ranging from lightweight in-memory configurations suitable for rapid experimentation to persistent runners required for production environments.

When individual agent responsibilities grow too broad, the course demonstrates how to distribute the workload across multiple specialized entities. Architectural patterns explored include parent-agent dispatchers that dynamically route tasks to appropriate sub-agents, sequential pipelines where outputs flow linearly from one stage to the next, parallel execution branches operating simultaneously, and iterative loops running until predefined completion conditions are satisfied. Among these options, sequential pipelines offer distinct advantages for debugging, as their fixed execution order ensures that any operational failure can be isolated to a single, predictable stage of the process.

Giving Agents Tools

An agent’s utility extends far beyond generating static text through its capacity to interact with external environments via tools. The curriculum categorizes these capabilities into four distinct types, starting with built-in utilities like Google Search that come natively integrated with the model. Function tools allow developers to wrap custom Python code into executable capabilities, while agent tools enable one agent to delegate subtasks to another while maintaining overall conversational control. Additionally, Model Context Protocol tools facilitate standardized connections to external services, eliminating the need to write bespoke client integrations for every third-party system.

Because the underlying model relies entirely on textual descriptions to determine when and how to invoke a function tool, proper documentation is paramount. Best practices emphasized in the curriculum focus on crafting clear docstrings, explicit type hints, and structured return values, ensuring that the model accurately understands the parameters of each tool and minimizes erroneous calls. For high-stakes or long-running operations, the course highlights the integration of human-in-the-loop approval mechanisms, allowing an agent to pause its execution cycle and await explicit confirmation from a human operator before proceeding.

Adding Memory Across Turns and Sessions

Because language models retain no native state between API calls, maintaining continuity requires passing the entire conversation history with every subsequent turn, which rapidly introduces token overhead and latency. The Agent Development Kit addresses this limitation by partitioning memory management into two distinct layers. Short-term memory is handled at the session level via a dedicated service that manages immediate conversation history, while long-term memory operates externally through a searchable service designed to preserve factual knowledge across entirely separate user sessions.

The underlying memory service supports multiple operational paradigms, ranging from basic keyword searches in lightweight configurations to semantic meaning-based searches in managed deployments. As sessions expand in length, context compaction and caching mechanisms are employed to maintain control over both operational costs and context window sizes. This falls under the broader umbrella of context engineering, which dictates how developers curate the specific information presented to the model on every turn. Retrieval from long-term memory can be executed reactively, where the agent decides when to query stored data, or proactively, where the system automatically retrieves relevant context before every turn to ensure the agent remains fully informed without needing to prompt the memory service explicitly.

Understanding Agent Quality and Evaluation

Because agentic systems are inherently non-deterministic, identical inputs can trigger entirely different execution paths during subsequent runs, making traditional testing methods insufficient. To ensure reliability, quality must be treated as a foundational element of system design rather than a final verification step. This approach relies heavily on comprehensive observability, which records operational telemetry through logs, traces, and metrics. Detailed execution traces allow developers to reconstruct the exact sequence of decisions an agent made, transforming opaque failures into debuggable events.

Furthermore, evaluating agent quality requires assessing both the final output and the underlying operational process, including the specific tools invoked and the sequence in which they were called. Evaluating the process is particularly critical because a correct final answer can occasionally mask an inefficient or flawed execution path. For instance, an agent that achieves a correct result only after repeatedly invoking the wrong tool three times incurs significantly higher computational costs than one that executes the task efficiently on the first attempt, making process evaluation essential for production optimization.

Taking an Agent Beyond the Notebook

Transitioning an agent from a local experimental notebook to a production environment requires standardized communication protocols and robust operational infrastructure. When agents developed by different teams across disparate frameworks and programming languages need to collaborate, the Agent2Agent protocol provides a standardized interface. By exposing an agent as a service equipped with a descriptive agent card, other systems can autonomously discover its capabilities and interact with it seamlessly.

On the deployment front, the curriculum explores hosting agents on managed runtimes such as Vertex AI Agent Engine, alongside the integration of continuous integration and continuous deployment pipelines and AgentOps practices to maintain system stability post-launch. Highlighting the cross-language flexibility of the ecosystem, the Agent Development Kit is made available for Go and Java environments in addition to Python. The self-paced learning path concludes with an optional capstone project, enabling developers to synthesize these architectural patterns, tool integrations, and memory management strategies into a fully functional autonomous agent of their own design.

Share:

Dwi Wanna writes for Tech Maze.