Lesson 15: where to go from here
Introduction
Section titled “Introduction”You made it. Fifteen lessons covering everything from “what is an agent?” to building multi-agent systems with protocols and production infrastructure. That is a solid foundation.
But foundations are meant to be built on. This final lesson is your launching pad - a curated map of where to go next depending on your goals, the best resources to bookmark, and the emerging areas that will shape the future of agent development.
What you have learned
Section titled “What you have learned”Let us do a quick flyover of the entire course. Use this as a refresher and a way to spot any areas you want to revisit.
Part 1: fundamentals
Section titled “Part 1: fundamentals”| Lesson | Title | Core Idea |
|---|---|---|
| 01 | What Are AI Agents? | Agents combine a reasoning model, tools, and an orchestration loop to pursue goals autonomously. They exist on a spectrum from simple tool-callers to self-evolving systems. |
| 02 | How Agents Think | LLMs are the reasoning engine. Understanding tokenization, context windows, and sampling helps you predict and control agent behavior. |
| 03 | Tools - Giving Agents Hands | Tools let agents interact with the world. Good tool design - clear names, typed parameters, helpful descriptions - directly impacts agent reliability. |
| 04 | Agentic Design Patterns | Patterns like ReAct, reflection, planning, and tool-use give structure to how agents solve problems. Pick the simplest pattern that works. |
| 05 | Memory and Context | Agents need memory at multiple levels - short-term (context window), session-level (conversation state), and long-term (persistent storage) - to handle complex tasks. |
| 06 | Planning and Reasoning | Agents break complex goals into steps through planning strategies. Chain-of-thought, tree-of-thought, and dynamic replanning each have their place. |
| 07 | Multi-Agent Systems | When one agent cannot handle everything, multiple specialized agents can collaborate through orchestration patterns like hierarchical, peer-to-peer, and blackboard systems. |
| 08 | Agentic RAG | Going beyond basic retrieval by letting agents decide what to search, evaluate results, and iteratively refine their knowledge before answering. |
| 09 | Evaluating and Testing Agents | Measuring agent quality requires task-specific metrics, trajectory analysis, and systematic test cases. Evaluation is not optional - it is how you know your agent works. |
| 10 | Guardrails and Safety | Agents need boundaries - input validation, output filtering, scope limits, and human-in-the-loop controls - to stay safe and trustworthy. |
Part 2: building and shipping
Section titled “Part 2: building and shipping”| Lesson | Title | Core Idea |
|---|---|---|
| 11 | From Prototype to Production | The gap between a working demo and a production agent is bridged by CI/CD, monitoring, graceful degradation, and operational practices. |
| 12 | Getting Started with Vertex AI and ADK | Google Cloud provides Vertex AI Agent Engine for managed deployment, Gemini models for reasoning, and ADK as an open-source toolkit for building agents. |
| 13 | Building Your First Agent | ADK agents need a name, model, and instructions. Start with LlmAgent, add tools incrementally, and test with adk web and adk eval. |
| 14 | Agent Protocols - MCP and A2A | MCP standardizes agent-to-tool communication. A2A standardizes agent-to-agent collaboration. Together they solve the integration problem. |
That is a lot of ground. If any of these summaries feel unfamiliar, go back and re-read that lesson before moving forward.
ELI5: where do you go after learning to drive?
Section titled “ELI5: where do you go after learning to drive?”Think about learning to drive a car. You took the classes (fundamentals), passed the written test (understanding the theory), and did your driving test (building your first agent). You can now drive.
But “being able to drive” opens up a world of choices. Some people want to drive to work every day (build practical agents). Some want to become a mechanic and understand the engine deeply (study the theory). Some want to drive cross-country (deploy at scale). And some want to race competitively (push the boundaries of what agents can do).
This lesson is your road atlas. It does not tell you where to go - it shows you all the roads and helps you pick the one that matches your destination.
Recommended learning paths
Section titled “Recommended learning paths”Not everyone has the same next step. Here are four paths based on common goals.
Path 1: “i want to build my first agent”
Section titled “Path 1: “i want to build my first agent””You have read the theory and you want to get your hands dirty.
Start here:
- Follow the ADK Quickstart end to end. Build the sample agent, run it locally, and make sure everything works.
- Modify the quickstart agent. Change the system instructions. Add a custom tool. Break it, fix it, and learn how the pieces fit.
- Clone the Agent Starter Pack for a production-ready template with CI/CD, monitoring, and deployment already configured.
- Pick a small, real problem and build an agent to solve it. Keep it scoped - one agent, two to three tools, a clear success metric.
Revisit: Lessons 3 (Tools), 13 (Building Your First Agent)
Path 2: “i want to improve an existing agent”
Section titled “Path 2: “i want to improve an existing agent””You have an agent but it is not performing well enough.
Start here:
- Go back to Lesson 9 and build an evaluation suite for your agent. You cannot improve what you cannot measure.
- Review the Google Cloud whitepaper on “Agent Quality” for systematic approaches to improving agent reliability and accuracy.
- Audit your system instructions using the guidelines from Lesson 13. Vague instructions are the most common source of poor behavior.
- Check your tool design. Are tool names clear? Are descriptions accurate? Are error cases handled?
- Add guardrails (Lesson 10) if you have not already. Reliability and safety go hand in hand.
Revisit: Lessons 9 (Evaluation), 10 (Guardrails), 4 (Design Patterns)
Path 3: “i want to deploy agents at scale”
Section titled “Path 3: “i want to deploy agents at scale””You have a working agent and you need to run it in production.
Start here:
- Re-read Lesson 11 (From Prototype to Production) with a focus on the operational concerns: monitoring, logging, error handling, and rollback.
- Explore Vertex AI Agent Engine for managed deployment that handles scaling, session management, and infrastructure.
- Study the Google Cloud whitepaper on “From Prototype to Production” for a detailed treatment of the deployment lifecycle.
- Set up CI/CD for your agent. Treat prompt changes with the same rigor as code changes - version them, review them, test them.
- Implement comprehensive observability. You need to see what your agent is doing in production, not just whether it returned a response.
Revisit: Lessons 11 (Production), 12 (Vertex AI and ADK)
Path 4: “i want to understand the theory deeper”
Section titled “Path 4: “i want to understand the theory deeper””You want the research-level understanding.
Start here:
- Read the Google Cloud whitepapers listed below. They provide in-depth technical treatment of every topic in this course.
- Follow the research papers on planning, reasoning, and multi-agent coordination referenced in those whitepapers.
- Experiment with advanced patterns - multi-agent systems (Lesson 7), agentic RAG (Lesson 8), and loop-based refinement agents.
- Study the MCP and A2A protocol specifications directly for a deep understanding of how agent communication works at the wire level.
Revisit: Lessons 2 (How Agents Think), 6 (Planning), 7 (Multi-Agent Systems)
Google Cloud Resources
Section titled “Google Cloud Resources”Codelabs
Section titled “Codelabs”Hands-on, guided tutorials you can complete in your browser:
- Google Cloud AI/ML Codelabs: https://codelabs.developers.google.com/?cat=AI - Browse the full catalog of AI codelabs including agent-specific tutorials, Gemini API guides, and Vertex AI walkthroughs.
Documentation
Section titled “Documentation”Your primary reference when building:
| Resource | What It Covers | Link |
|---|---|---|
| Vertex AI Docs | Agent Engine, model serving, evaluation, and the full Vertex AI platform | cloud.google.com/vertex-ai/docs |
| ADK Docs | Agent Development Kit - building, testing, and deploying agents | google.github.io/adk-docs |
| Gemini API Docs | Model capabilities, function calling, context caching, and API reference | ai.google.dev/docs |
| Google Cloud AI | Overview of all AI services on Google Cloud | cloud.google.com/ai |
Templates and starter projects
Section titled “Templates and starter projects”Do not start from scratch when you do not have to:
- Agent Starter Pack: https://github.com/GoogleCloudPlatform/agent-starter-pack - A production-ready template for building and deploying agents on Google Cloud. Includes CI/CD pipelines, monitoring setup, evaluation frameworks, and deployment configurations. This is the fastest way to go from idea to production.
Community
Section titled “Community”Connect with other agent builders:
- Google Cloud Community forums - Ask questions and share what you are building
- Stack Overflow - Tag questions with
google-cloud-vertex-aiorgoogle-adk - GitHub Issues - Report bugs and request features on the ADK repository
- Google Cloud Discord - Real-time conversations with other developers
Building agents can feel isolating when you are the only one on your team doing it. The community is where you find people who have hit the same problems you are facing. Do not hesitate to ask questions - the ecosystem is young enough that everyone is still learning.
Tutorials and samples
Section titled “Tutorials and samples”Beyond the official docs, look for:
- Sample agents in the ADK repository - The ADK GitHub repo includes example agents that demonstrate common patterns like multi-tool agents, sequential workflows, and agent teams
- Google Cloud blog posts - The Google Cloud blog regularly publishes walkthroughs of agent architectures and deployment patterns
- Conference talks - Google I/O and Google Cloud Next sessions on agents and AI are often recorded and published
Key Google Cloud whitepapers on agents
Section titled “Key Google Cloud whitepapers on agents”Google Cloud has published a series of in-depth whitepapers covering the agent landscape. These go deeper than our lessons and are excellent references for both practitioners and decision-makers.
| Whitepaper | What It Covers |
|---|---|
| Introduction to Agents | Foundational concepts - what agents are, core components, cognitive architecture, and the spectrum of agent capabilities |
| Agent Quality | Systematic approaches to measuring and improving agent performance - evaluation methodologies, metrics, and quality assurance strategies |
| Agent Tools and Interoperability with MCP | Deep dive into tool design, the Model Context Protocol, and how to build interoperable agent-tool ecosystems |
| Context Engineering: Sessions and Memory | How agents manage context - session state, memory architectures, context window optimization, and long-term knowledge retention |
| From Prototype to Production | The complete lifecycle of taking an agent from demo to deployed - infrastructure, CI/CD, monitoring, scaling, and operational best practices |
| Agents Companion | A practical reference guide that ties all the whitepapers together with actionable guidance and decision frameworks |
These whitepapers are valuable whether you are building on Google Cloud or not. The concepts and patterns they describe are broadly applicable.
Open source projects to explore
Section titled “Open source projects to explore”Google projects
Section titled “Google projects”| Project | What It Is | Link |
|---|---|---|
| ADK (Agent Development Kit) | Google’s open-source, code-first toolkit for building, evaluating, and deploying agents | github.com/google/adk-python |
| Agent Starter Pack | Production-ready templates for agent projects on Google Cloud | github.com/GoogleCloudPlatform/agent-starter-pack |
Community frameworks
Section titled “Community frameworks”The agent ecosystem is broader than any single vendor. These community frameworks offer different approaches and are worth understanding:
| Framework | Approach | Best For |
|---|---|---|
| LangChain | Modular components for building LLM applications with chains and agents | Rapid prototyping, wide ecosystem of integrations |
| LangGraph | Graph-based agent orchestration built on LangChain | Complex multi-step workflows, stateful agents |
| CrewAI | Role-based multi-agent collaboration framework | Teams of specialized agents working together |
Each framework makes different trade-offs. ADK emphasizes Google Cloud integration, code-first design, and production deployment. LangChain emphasizes breadth of integrations. CrewAI emphasizes the multi-agent team metaphor. There is no single “best” framework - the right choice depends on your requirements, existing infrastructure, and team preferences.
A note on framework choice: Do not spend weeks evaluating frameworks. Pick one that fits your ecosystem, build something with it, and switch later if you need to. The concepts transfer across frameworks. What you learn about tool design in ADK applies in LangChain. What you learn about evaluation in one framework applies in all of them. Frameworks are vehicles, not destinations.
Protocol implementations
Section titled “Protocol implementations”- MCP Specification: modelcontextprotocol.io - The protocol spec and reference implementations
- A2A Protocol: a2a-protocol.org - Specification and documentation
Emerging areas to watch
Section titled “Emerging areas to watch”The agent field is moving rapidly. Here are areas that will likely have a significant impact in the near future.
Computer use agents
Section titled “Computer use agents”Agents that can see and interact with graphical user interfaces - clicking buttons, filling forms, navigating websites - just like a human user. This opens up automation for applications that have no API, only a visual interface.
Why it matters: Most enterprise software was designed for human interaction through GUIs. Computer use agents can automate workflows that were previously impossible to automate without building custom integrations.
What to watch for: Improvements in vision-language models, standardized frameworks for GUI interaction, and security models for agents that control desktop and browser environments.
Self-Evolving Agents
Section titled “Self-Evolving Agents”Agents that learn from their own past performance - analyzing what worked, what failed, and why. They update their strategies, refine their prompts, and improve their tool usage over time without human intervention.
Why it matters: Today, improving an agent requires a human to review logs, identify issues, and make changes. Self-evolving agents could dramatically reduce this maintenance burden.
What to watch for: Better approaches to agent self-reflection, automated prompt optimization, and safe exploration strategies that let agents try new approaches without breaking things.
Agentic commerce
Section titled “Agentic commerce”Agents that can discover products and services, negotiate terms, make purchases, and manage transactions on behalf of users. Think of a travel agent that does not just plan your trip but actually books it - comparing prices, applying discounts, and handling payment.
Why it matters: This shifts agents from “information helpers” to “action takers” in economic activity. The trust and safety implications are significant.
What to watch for: Standards for agent-to-merchant communication, payment authorization frameworks, and consumer protection models for AI-mediated transactions.
Continuous learning in production
Section titled “Continuous learning in production”Agents that update their knowledge and capabilities based on production interactions without requiring redeployment. This includes learning new facts, adapting to changing user needs, and incorporating feedback loops.
Why it matters: Today, updating an agent’s knowledge requires redeploying with new instructions or updating a knowledge base. Continuous learning could make agents that stay current automatically.
What to watch for: Safe online learning techniques, quality controls for learned information, and architectures that separate stable capabilities from evolving knowledge.
Multi-Modal Agents
Section titled “Multi-Modal Agents”Agents that work with images, audio, video, and documents alongside text. A multi-modal agent might analyze a screenshot of an error, listen to a customer support call, or process a PDF invoice - all as part of a single workflow.
Why it matters: The real world is not text-only. Many business processes involve documents, images, and recordings. Multi-modal agents can handle these workflows without requiring a human to manually transcribe or describe non-text content.
What to watch for: Improvements in vision-language models, standardized ways to pass multi-modal content through agent protocols, and frameworks that handle multi-modal tool inputs and outputs natively.
Agent observability and debugging
Section titled “Agent observability and debugging”As agents become more complex, understanding what they are doing and why becomes harder. New tools and practices are emerging for tracing agent decision-making, visualizing multi-step execution, and diagnosing failures in production.
Why it matters: You cannot fix what you cannot see. Today, debugging an agent often means reading logs line by line. Better observability tools will make agent development feel more like modern software development with proper debuggers and profilers.
What to watch for: Dedicated agent tracing platforms, standardized telemetry formats for agent execution, and visualization tools for multi-agent interactions.
Common patterns for your first real project
Section titled “Common patterns for your first real project”Once you move beyond tutorials, here are practical project patterns that work well as a first real build:
The internal knowledge agent
Section titled “The internal knowledge agent”What it does: Answers questions about your team’s documentation, runbooks, or codebase.
Why it is a good first project: The scope is clear, the data is accessible, and you can measure success easily (does it answer correctly?). It combines RAG with tool use and gives your team immediate value.
Tools needed: A document retrieval tool (vector search or API to your docs), optionally Google Search for fallback.
The triage agent
Section titled “The triage agent”What it does: Reads incoming items (bug reports, support tickets, pull requests) and categorizes, prioritizes, or routes them.
Why it is a good first project: Classification tasks play to LLM strengths. The output is structured and easy to evaluate. And the volume of items in most organizations makes this genuinely useful.
Tools needed: An API tool to read items from your issue tracker or ticketing system, and a tool to update labels or assignees.
The daily digest agent
Section titled “The daily digest agent”What it does: Gathers information from multiple sources (email, Slack, calendar, project management tool) and produces a summary.
Why it is a good first project: It exercises multiple tools and basic synthesis without requiring complex multi-step reasoning. The output is easy for a human to review.
Tools needed: MCP servers or custom tools for each data source, a formatting tool for the output.
The code review helper
Section titled “The code review helper”What it does: Reviews pull requests for common issues - missing tests, style violations, potential bugs, unclear naming.
Why it is a good first project: Developers can immediately validate the output against their own judgment. It is low-risk (suggestions, not automated changes) and high-value.
Tools needed: A tool to read PR diffs from your source control system, optionally a tool to post review comments.
A checklist for your next agent project
Section titled “A checklist for your next agent project”Use this as a planning tool when you start your next build:
Before you start
Section titled “Before you start”- Define the goal clearly - what should the agent accomplish?
- Verify an agent is the right approach (Lesson 1 decision flowchart)
- Identify the tools and data sources the agent needs
- Choose a model appropriate for the task complexity
- Set up your development environment (ADK, API access, credentials)
During development
Section titled “During development”- Write detailed system instructions (role, scope, boundaries, examples)
- Build and test tools individually before connecting them to the agent
- Create evaluation cases early - at least 5-10 to start
- Test locally with
adk webbefore deploying anywhere - Add guardrails for safety and reliability
Before deployment
Section titled “Before deployment”- Run a thorough evaluation suite and address failures
- Set up monitoring and logging
- Define rollback procedures
- Plan for error handling and graceful degradation
- Review security - authentication, authorization, data handling
After deployment
Section titled “After deployment”- Monitor agent performance metrics (latency, success rate, cost)
- Review logs regularly for unexpected behaviors
- Collect user feedback and incorporate it into eval cases
- Iterate on instructions and tools based on production data
- Keep dependencies (models, tools, MCP servers) up to date
A bookmarkable resource list
Section titled “A bookmarkable resource list”Keep these links handy. They are the primary references you will come back to:
Learning and Building:
- ADK Documentation: https://google.github.io/adk-docs/
- ADK Quickstart: https://google.github.io/adk-docs/get-started/quickstart/
- Agent Starter Pack: https://github.com/GoogleCloudPlatform/agent-starter-pack
- Gemini API Docs: https://ai.google.dev/docs
Google Cloud Platform:
- Vertex AI Docs: https://cloud.google.com/vertex-ai/docs
- Agent Engine: https://cloud.google.com/vertex-ai/generative-ai/docs/agent-engine/overview
- AI/ML Codelabs: https://codelabs.developers.google.com/?cat=AI
Protocols:
- MCP Specification: https://modelcontextprotocol.io
- A2A Protocol: https://a2a-protocol.org/latest/
- MCP Tools in ADK: https://google.github.io/adk-docs/tools/mcp-tools/
Open Source:
- ADK Python: https://github.com/google/adk-python
Staying current
Section titled “Staying current”The agent ecosystem moves fast. Here is a practical strategy for keeping up without drowning in information.
What to follow
Section titled “What to follow”- ADK release notes: Check the ADK GitHub repository for new releases. Major versions often introduce new agent types, tool integrations, or deployment options.
- Vertex AI changelog: Google Cloud regularly ships new features for Agent Engine, model serving, and evaluation. The Vertex AI documentation includes a changelog.
- Model releases: New Gemini model versions can unlock capabilities that were not possible before - better reasoning, longer context windows, improved function calling. Test new models with your existing eval suite to see if they improve performance.
- Protocol updates: Both MCP and A2A are actively evolving. Watch for new primitives, security improvements, and ecosystem growth.
What to ignore (for now)
Section titled “What to ignore (for now)”Not every new development requires your attention. Skip things that:
- Solve a problem you do not have yet
- Require rearchitecting a system that is working fine
- Are announcements without available implementations
- Are benchmark results without practical applications
Focus on what helps you build better agents today. File the rest away for later.
A final note
Section titled “A final note”The best way to learn agent development is to build agents. Start small. Pick a problem you actually have - maybe it is summarizing your morning emails, or looking up information across multiple internal tools, or triaging bug reports. Build a simple agent to solve it. One model, one or two tools, clear instructions.
Once that works, iterate. Add another tool. Improve the instructions. Write eval cases. Connect to an MCP server. Try a multi-agent pattern. Each iteration teaches you something the docs cannot.
The field is moving fast. New models with better reasoning ship regularly. New tools and protocols emerge. Best practices evolve as more teams put agents into production. The fundamentals you learned in this course - the agent loop, tool design, memory management, evaluation, safety - will stay relevant even as the specifics change. But the specific APIs, model versions, and framework features will evolve.
Bookmark the resource list above and check back often. Follow the ADK and Vertex AI changelogs. Read the whitepapers when new ones come out. Join the community forums and see what other people are building.
And most importantly: ship something. The gap between “I understand agents” and “I have built and deployed an agent” is where the real learning happens.
Good luck building.
Course complete
Section titled “Course complete”Congratulations on finishing AI Agents 101. You have gone from understanding what agents are to knowing how to build, test, deploy, and connect them using industry-standard tools and protocols.