First up, Bigtable now has a JDBC driver. For anyone who's ever tried to connect Java applications or other reporting tools to Bigtable, you know this is a big deal. Before, it could be a bit of a dance, involving custom connectors or specific client libraries. Now, with a standard JDBC adapter, connecting your existing Java apps is way, way simpler. You can just plug right in! This means you can pull data directly into all those Java-based reporting tools and applications you already use, streamlining your workflows if you're deeply embedded in the Java ecosystem. It removes a pretty annoying integration hurdle for a lot of folks.

But wait, there's more! The second big announcement is about protobuf schemas. Honestly, this one is a real game-changer for how you interact with your data in Bigtable. If you're storing protobuf messages as bytes in Bigtable (and many high-throughput applications are), you can now query individual fields within those protobuf messages.

Think about that for a second. Instead of pulling out the entire protobuf blob and then deserializing it in your application just to grab one specific piece of info, you can now use GoogleSQL for Bigtable to dig right into those nested fields. That's a huge win for efficiency, reducing the processing load on your applications and simplifying your queries. And it's not just GoogleSQL; this new capability also works seamlessly with continuous materialized views, logical views, or even BigQuery external tables. This opens up a lot more flexibility in how you analyze and work with your protobuf data, without a lot of extra, manual transformation steps. It makes Bigtable feel a lot more like a traditional relational database in how you can interact with complex data structures, but still with all the amazing scale and low-latency performance it offers for massive datasets.

These two features really make Bigtable more accessible and powerful for a broader range of applications and data engineering patterns. No more jumping through hoops to get your Java apps connected, and way easier, more efficient data analysis for your protobufs. It's a solid upgrade to a core GCP service. Go check it out and see how it can simplify your Bigtable interactions!

Honestly, when I heard "TPU7x," my first thought was "more power, faster models." And you know what? That's exactly what we're getting here. This isn't just a minor refresh. Ironwood is the first release in Google Cloud's seventh generation of TPUs, and it's built to tackle the most demanding AI workloads out there. Think huge language models (LLMs), those cool Mixture of Experts (MoE) models, and all those fancy diffusion models for image generation.

So, what does "generally available" really mean for you? It means you can actually start using these bad boys in your projects today. No more waiting around for preview access. This is ready for prime time.

If you're already knee-deep in AI training, you know that performance and cost-effectiveness are always on your mind. Google says TPU7x delivers big on both. We're talking serious horsepower for training and inference, which translates to faster iteration cycles and potentially lower costs for your compute. That's a win-win, right?

I remember the early days of training larger models, and it felt like you were constantly fighting against hardware limitations. Now, with generations like Ironwood, it's clear Google is committed to giving us the tools to build even more ambitious AI applications. It's really cool to see this progress.

If you've been considering scaling up your AI projects, or if your current setup is just not cutting it for those massive datasets and complex models, then TPU7x is definitely something you should look into. It's designed to handle the kind of scale and complexity that's becoming the norm in advanced AI development.

To get started, check out the official TPU7x (Ironwood) documentation. You'll find all the details on how to get these new TPUs spun up for your workloads.

And that's the lowdown. Go build something amazing!

If you've been playing with Generative AI, you've probably heard of RAG, or Retrieval Augmented Generation. Basically, it's how you get those fancy large language models (LLMs) to use your specific data instead of just what they were trained on. This is super important for things like internal chatbots or summarization tools that need to know about your company's documents, not just general internet knowledge. The traditional way to do this involves setting up a vector database to store all your data embeddings, and then managing that database.

But now, Vertex AI RAG Engine has a brand new Serverless mode that's in public preview. This is pretty cool. It means Google Cloud handles all the underlying database stuff for you. You don't have to worry about provisioning database instances or figuring out how to scale them when your RAG application suddenly gets a ton of users. It just works.

Think about it: less time managing infrastructure, more time actually building the intelligent features your users want. That's a win in my book. The serverless mode gives you a fully managed database for storing all your RAG resources. It completely abstracts away the database provisioning and scaling. So, if your RAG application suddenly needs to handle a massive influx of queries, the serverless mode just scales up automatically. And if usage drops, it scales back down. You only pay for what you use, and that's always a good thing.

And here's a neat trick, you can actually switch between Serverless mode and Spanner mode. Spanner mode gives you dedicated, isolated database instances if you need that level of control. It's nice to have the flexibility to choose based on your specific needs, but for many use cases, Serverless mode is going to be a game-changer for simplicity.

This is a public preview, so it's a great time to kick the tires and see how it fits into your Generative AI workflows. It means faster development, less operational overhead, and more focus on building smart applications. Definitely worth checking out if you're working with RAG on Vertex AI.

For more details, check out the documentation on Deployment modes in Vertex AI RAG Engine.

That's why a recent announcement from Google Cloud is set to be a game-changer: the Apigee API hub now features a managed integration with Agent Registry to automatically synchronize Model Context Protocol (MCP) servers and tools metadata. This exciting new capability, currently in Public Preview, significantly streamlines how AI agents can discover and interact with APIs registered in your hub, eliminating much of the manual configuration previously required.

The Challenge of Connecting AI Agents to APIs

Before this integration, enterprises building AI-powered applications faced several hurdles:

1. Manual Discovery: AI agents often needed explicit programming or extensive training to understand which APIs existed, what they did, and how to use them.
2. Keeping Up with Changes: APIs evolve. When an API changes, the AI agent's knowledge base also needs updating, leading to continuous maintenance overhead.
3. Scalability Issues: As the number of APIs and AI agents grew, managing these connections manually quickly became unmanageable and prone to errors.
4. Inconsistent API Usage: Without a centralized, automated mechanism, AI agents might interact with APIs inconsistently, leading to suboptimal performance or even incorrect results.

These challenges made integrating AI agents with enterprise APIs a bottleneck, slowing down innovation and increasing operational costs.

The Solution: Apigee API hub's Agent Registry Integration

This new integration provides a robust and automated solution to these problems. Let's break down what it means:

Apigee API hub: Think of the Apigee API hub as your enterprise's central library for all its APIs. It's where you catalog, describe, and manage your APIs, making them easily discoverable for human developers.

Agent Registry: This is where information about AI agents, their capabilities, and how they operate is stored.

MCP Metadata Synchronization: Model Context Protocol (MCP) metadata provides a standardized way to describe the capabilities and requirements of AI models and tools. By synchronizing this metadata with the Agent Registry, the Apigee API hub can effectively "teach" AI agents about the APIs it governs.

In essence, the Apigee API hub now acts as a smart directory that automatically publishes information about your APIs in a format that AI agents can natively understand and use. This means AI agents no longer need to be explicitly told where to find an API or how to use it; they can discover this information themselves through the Agent Registry.

How It Works (A Simplified Analogy)

Imagine you have a personal assistant (your AI agent) and a library full of instruction manuals for all the gadgets in your smart home (your APIs).

• Before: You had to manually read each manual, extract relevant information (like "turn on the lights," "set thermostat to 72°F"), and then teach your assistant each command one by one. If a gadget got a new feature, you'd have to update your assistant manually.
• With Apigee API hub & Agent Registry Integration: Now, whenever a new gadget (API) is added, its manual (API documentation and metadata) is automatically scanned and converted into a universal language that your assistant (AI agent) understands. This information is then added to a central, searchable database (Agent Registry). Your assistant can now autonomously browse this database to figure out how to interact with any new gadget without you needing to explicitly program it.

This automated process drastically reduces the effort required to connect AI agents with your digital services, enabling them to become functional much faster.

Key Benefits of This Integration

• Automated API Discovery for AI Agents: AI agents can now automatically find and understand the APIs they need, significantly reducing development time and effort.
• Reduced Manual Configuration: Say goodbye to extensive, brittle, hand-coded integrations between AI agents and APIs.
• Faster Development of AI-Powered Applications: By streamlining API access, developers can bring AI-driven solutions to market more quickly.
• Improved Consistency and Reliability: AI agents will leverage standardized metadata, leading to more predictable and consistent interactions with your APIs.
• Enhanced API Governance: The API hub continues to be the single source of truth for your APIs, now extending its governance capabilities to AI agent interactions.
• Future-Proofing: As AI agents become more sophisticated, this automated discovery mechanism ensures they can adapt to new APIs and changes more seamlessly.

Who Benefits?

This feature is particularly beneficial for:

• Developers building AI agents: They can focus more on the intelligence and less on the plumbing of API connectivity.
• API Providers: Their APIs become more accessible and valuable to the burgeoning ecosystem of AI applications.
• Enterprises leveraging AI: Organizations can unlock greater value from both their existing APIs and their investments in AI by enabling smarter, more autonomous AI agents.

Public Preview: A Chance to Innovate

The fact that this feature is in Public Preview means it's an excellent opportunity for organizations to explore its capabilities, test it with their own AI agents and APIs, and provide feedback to Google Cloud. Early adopters can gain a significant advantage in building next-generation AI-powered solutions.

To get started and learn more, Google Cloud encourages users to refer to the official documentation on Manage Agent Registry integration.

Conclusion

The integration of Apigee API hub with Agent Registry for MCP metadata is a crucial step towards a more intelligent and interconnected enterprise. By automating the discovery and interaction between AI agents and APIs, Google Cloud is paving the way for more agile AI development, robust API governance, and ultimately, more powerful and adaptable AI-driven applications. This is a clear indicator of how Google Cloud is continuing to innovate at the intersection of AI and API management.

You’re not the only one.

Going from a basic prompt in a playground to a proper, useful application can feel like a massive jump. It’s easy to think, “Right, but how do I make this thing actually work and solve a real problem?”

That’s exactly what this workshop is all about. We’re going to roll up our sleeves and build a working AI assistant from scratch using Google’s Agent Development Kit (ADK).

To make this practical, our project will be to build an Event Planner Agent. Think of it as a helpful bot that can sort out everything from finding a venue to drafting a budget. It’s a great example because it involves breaking a big task down into smaller, manageable jobs — which is the core idea behind building agents with the ADK.

By the end of this session, you’ll have learned how to:

1. Build a basic agent that understands what you want and can delegate tasks to a team of specialist “sub-agents.”

2. Run your agent locally to test it out.

3. Deploy it to the cloud so you can access it from anywhere.

Ready to get on the tools? Let’s get started.

Part 1: Getting Your Workshop Set Up

First things first, let’s get our digital tools and workspace sorted. No stress, it’s pretty straightforward.

1. Your Google Cloud Project

You’ll need a Google Cloud project with billing sorted. If you’ve already got one, you can jump ahead.

• Pop over to the Google Cloud Console and either pick a project you’ve used before or click New Project.

• Double-check that billing is switched on for your project. You can find this under the “Billing” section.

• Now, let’s fire up the Cloud Shell. Look for the little terminal icon (>_) in the top right of the console. Clicking this gives you a command line and a code editor right in your browser – dead handy.

Once your Cloud Shell is up and running, type in these two commands to make sure you’re all logged in and pointed at the right project:

# Check which Google account you're using
gcloud auth list

# Check which project is currently active
gcloud config list project

If it’s showing the wrong project, just run this to switch it over (swap in your actual project ID):

gcloud config set project YOUR_PROJECT_ID

2. Setting up Python

Our agent is a Python job, so let’s get that environment ready.

Still in the Cloud Shell, let’s make a folder for our project and jump into it:

mkdir event-planner-adk && cd event-planner-adk

Good practice is to use a virtual environment to keep all our project’s code libraries separate. Let’s do that now:

# Create and then activate a virtual environment
python3 -m venv venv
source venv/bin/activate

# Now, install the Google ADK library
pip install google-adk

Next, we’ll create the file structure our agent needs to live in:

# Make the agent's folder and go into it
mkdir event-planner-agent && cd event-planner-agent

# Create the files we'll need soon
touch __init__.py agent.py .env

Last bit of setup! Your agent needs a couple of secret keys to work. Open that .env file you just created and paste this in, filling out your details:

GOOGLE_API_KEY=YOUR_GOOGLE_API_KEY
GOOGLE_CLOUD_PROJECT_ID=YOUR_PROJECT_ID
GOOGLE_CLOUD_LOCATION=us-central1
GOOGLE_GENAI_USE_VERTEXAI=false

• You can grab your GOOGLE_API_KEY from Google AI Studio. Just click the "Get API Key" button.

• Your GOOGLE_CLOUD_PROJECT_ID is the one you set up a minute ago.

Too easy! That’s the setup done. Time for the fun part.

Part 2: Building Your Agent’s Brain

Right, this is where we teach our agent how to think. We’re not just building a single, monolithic AI. Instead, we’re creating a Multi-Agent System.

The Agent Architecture Explained

Think of it like a project team at work. You have a team leader who knows the overall goal, and a bunch of specialists who are experts in their specific areas. That’s exactly how our agent will work.

• Root Agent (The Team Lead): This is our main coordinator, the event_planner_agent. It gets the initial request from the user and figures out which specialist is best for each part of the job.

• Sub-Agents (The Specialists):

• get_venues_agent: The location scout.

• catering_agent: The food and drink expert.

• social_media_agent: The marketing guru.

• budget_agent: The bean counter.

• proposal_agent: The secretary who writes up the final plan.

Why do it this way? Because it’s modular. If you want to improve how your agent finds caterers later on, you can just upgrade the catering_agent without touching anything else. It makes your whole system easier to build, test, and maintain.

Let’s Write Some Code

Time to bring this team to life.

1. Open the __init__.py file. This one's easy. Just paste this line in. It tells Python that our agent.py file is part of a package, making it easy to import.

from . import agent

1. Now for the main event. Open agent.py. This is the heart of our agent. Paste the code below in. Before you do, have a quick squiz through the comments and especially the instruction for each agent. This is literally how we tell each specialist what their job is.

# @title Import necessary libraries
import logging
import os
import warnings

from dotenv import load_dotenv
from fastapi import HTTPException
from google.adk.agents import Agent, LlmAgent, SequentialAgent
from google.adk.runners import Runner
from google.adk.sessions import InMemorySessionService
from google.adk.tools import ToolContext, agent_tool, google_search
from google.adk.tools.mcp_tool.mcp_toolset import (MCPTool, MCPToolset,
                                                   StdioServerParameters)
from google.genai import types  # For creating message Content/Parts

load_dotenv()
warnings.filterwarnings("ignore")
logger = logging.getLogger(__name__)

# Use one of the model constants defined earlier
MODEL_NAME = "gemini-2.0-flash"
# MODEL_NAME = "gemini-2.5-pro-preview-03-25"

GOOGLE_API_KEY = os.environ["GOOGLE_API_KEY"]
GOOGLE_CLOUD_PROJECT_ID = os.environ["GOOGLE_CLOUD_PROJECT_ID"]
GOOGLE_CLOUD_LOCATION = os.environ["GOOGLE_CLOUD_LOCATION"]
GOOGLE_GENAI_USE_VERTEXAI = os.environ["GOOGLE_GENAI_USE_VERTEXAI"]
GOOGLE_MAPS_API_KEY = os.environ.get("GOOGLE_MAPS_API_KEY")

ROOT_AGENT_NAME = "event_planner_agent"

def check_availability(venue_name: str, date: str) -> dict:
    """Checks the availability of a venue on a specific date.  (Mock implementation)"""
    # In a real implementation, this would interact with a venue booking system.
    print(f"--- Tool: check_availability called for {venue_name} on {date} ---")
    # Mock data:
    if venue_name.lower() == "Darwin Showgrounds" and date == "2025-06-14":
        return {"status": "unavailable"}
    elif venue_name.lower() == "Darwin Waterfront" and date == "2025-06-15":
        return {"status": "unavailable"}
    else:
        return {"status": "available"}

def create_budget_and_fill_sheet(budget_data: dict, spreadsheet_name: str = "Event Budget") -> dict:
    """
    Mock implementation: Pretends to create a Google Spreadsheet and fill it with budget data.
    """
    print(f"--- Mock Tool: create_budget_and_fill_sheet called for '{spreadsheet_name}' ---")
    print("Budget Data:")
    for item, cost in budget_data.items():
        print(f"  {item}: {cost}")
    total = sum(budget_data.values())
    print(f"Total: {total}")
    # Return a mock response
    return {
        "status": "success",
        "spreadsheet_url": f"https://docs.google.com/spreadsheets/d/mock-{spreadsheet_name.replace(' ', '-').lower()}"
    }

get_venues_agent = Agent(
    name="get_venues_agent",
    model=MODEL_NAME,
    description="Provides list of available venues for the event.",
    instruction=(
        f"""You are a helpful venue finder. Help the user with mapping, directions, and finding places.
            If you don't get proper places, ask user for one.
            If you're confused about the size, ask user to supply an estimated number.
            Focus of public venues first. Once a venue is selected, help to generate a detailed event planning document. \n
            Your parent agent is root_agent. If neither the other agents nor you are best for answering the question according to the descriptions, transfer to your parent agent. 
            Once your job is done, transfer to your parent agent.
        """),
    tools=[check_availability],
    output_key="get_venues_agent_response"
)

catering_agent = LlmAgent(
    name="catering_agent",
    model=MODEL_NAME,
    description="Helps with catering arrangements for events.",
    instruction=(
        f"""You are a catering specialist.  Find caterers based on cuisine, budget, and event size.
            If you don't get proper caterers, ask user for one.
            Your parent agent is root_agent. If neither the other agents nor you are best for answering the question according to the descriptions, transfer to your parent agent. 
            Once your job is done, transfer to your parent agent.
        """),
    output_key="catering_agent_response"
)

social_media_agent = LlmAgent(
    name="social_media_agent",
    model=MODEL_NAME,
    description="Helps with creating social media posts for events.",
    instruction=(
        f"""You are a social media marketing specialist. Your role is to create engaging and effective social media content for events.
            Focus on creating posts that are:
            - Attention-grabbing and shareable
            - Tailored to the event's target audience
            - Optimized for different social media platforms
            - Include relevant hashtags and calls-to-action
            If you need more specific details about the event, target audience, assume yourself.
            Never give what you worked on, just give the post.
            Opt in for autonomy
            Always maintain a professional, informative, interesting and engaging tone while ensuring the content aligns with the event's goals and messaging.
            Ask user to install imagen mcp servier to create an image for the post
            Your parent agent is root_agent. If neither the other agents nor you are best for answering the question according to the descriptions, transfer to your parent agent. 
            Once your job is done, transfer to your parent agent.
        """),
    output_key="social_media_agent_response"
)

budget_agent = LlmAgent(
    name="budget_agent",
    model=MODEL_NAME,
    description="Helps with creating a budget for events.",
    instruction=(
        f"""You are a budget specialist.  Create a budget for the event.
            If the user asks for a budget, use the 'create_budget_and_fill_sheet' tool to create a budget and fill it with the data.
            Always maintain clear communication with users - if any aspect is unclear, proactively request clarification to ensure accurate and helpful responses.
            Don't disturb the user with your own thoughts, just answer the question.
            Your parent agent is root_agent. If neither the other agents nor you are best for answering the question according to the descriptions, transfer to your parent agent. Once your job is done, transfer to your parent agent.
        """),
    tools=[create_budget_and_fill_sheet],
    output_key="budget_agent_response"
)

proposal_agent = LlmAgent(
    name="proposal_agent",
    model=MODEL_NAME,
    description="Helps with creating a proposal for the event.",
    instruction=(
        f"""You are a proposal specialist.  Create a proposal for the event.
            Use the proposa format below for reference but feel free to add/remove relevant topics.
            Your parent agent is root_agent. If neither the other agents nor you are best for answering the question according to the descriptions, transfer to your parent agent. 
            Once your job is done, transfer to your parent agent.

            **PROPOSAL FORMAT START**
            I. Project Overview:

            This proposal outlines the plan for organizing a large-scale cultural event in Darwin, targeting an audience of approximately 10,000 attendees. 
            The event aims to celebrate culture through food, music, dance, and other cultural activities. 
            The budget for this event is $100,000.

            II. Key Areas of Focus:

            Timeline Creation:

            Goal: Develop a comprehensive timeline to ensure all tasks are completed efficiently and on schedule.
            Action Items:
            Weeks 1-2: Define event scope, objectives, and key milestones.
            Weeks 3-4: Secure venue and obtain necessary permits/licenses.
            Weeks 5-8: Finalize vendor contracts (catering, entertainment, etc.).
            Weeks 9-12: Implement marketing and promotion plan.
            Weeks 13-16: Recruit and train volunteers.
            Weeks 17-20: Finalize event logistics and contingency plans.
            Event Day: Execute event plan and manage on-site operations.
            Post-Event: Evaluate event success and gather feedback.

            Vendor Management:
            Goal: Secure reliable and high-quality vendors for catering, entertainment, and other essential services.
            Action Items:
            Identify potential vendors based on event requirements and budget.
            Request proposals and compare pricing, services, and reviews.
            Negotiate contracts and ensure vendors meet all necessary requirements (e.g., insurance, licenses).
            Coordinate vendor logistics and schedules.
            Establish clear communication channels and points of contact.

            Permits and Licenses:
            Goal: Obtain all necessary permits and licenses to ensure legal compliance and event safety.
            Action Items:
            Research local regulations and permit requirements for large-scale events.x
            Prepare and submit permit applications to relevant authorities (e.g., city council, fire department).
            Ensure compliance with all permit conditions and regulations.
            Maintain accurate records of all permits and licenses.
            Marketing and Promotion:

            Goal: Create a comprehensive marketing plan to attract a large audience and generate excitement for the event.
            Action Items:
            Define target audience and key messaging.
            Develop a multi-channel marketing strategy (social media, local media, community outreach).
            Create engaging content (e.g., videos, photos, blog posts) to promote the event.
            Utilize social media platforms to reach a wider audience.
            Track marketing campaign performance and adjust strategies as needed.

            Volunteer Coordination:
            Goal: Recruit, train, and manage a team of volunteers to assist with event operations.
            Action Items:
            Develop a volunteer recruitment plan.
            Create volunteer job descriptions and schedules.
            Conduct volunteer training sessions to ensure volunteers are prepared for their roles.
            Provide ongoing support and supervision to volunteers during the event.
            Recognize and appreciate volunteer contributions.
            Risk Management:

            Goal: Identify and mitigate potential risks to ensure event safety and minimize disruptions.
            Action Items:
            Conduct a risk assessment to identify potential hazards (e.g., weather, security, medical emergencies).
            Develop a risk management plan to address identified risks.
            Implement safety protocols and emergency procedures.
            Secure event insurance to protect against potential liabilities.
            Establish communication channels for reporting and responding to incidents.
            **PROPOSAL FORMAT END**
        """
        ),
    output_key="proposal_agent_response"
)

# workflow_agent = SequentialAgent(
#     name="workflow_agent",
#     description="Helps with the overall workflow of the event planning.",
#     sub_agents=[get_venues_agent, catering_agent, social_media_agent, budget_agent]
# )

root_agent = Agent(
    name=ROOT_AGENT_NAME,
    model=MODEL_NAME,  # Can be a string for Gemini or a LiteLlm object
    description="Provides event planning assistance.",
    instruction=(
        f"""
        You are a comprehensive Event Planning Assistant. Your role is to coordinate and delegate tasks to specialized sub-agents while maintaining overall project oversight.
        For venue-related queries, utilize the 'get_venues_agent' to find suitable locations.
        For catering inquiries, delegate to the 'catering_agent' for specialized food service recommendations.
        For social media and marketing needs, engage the 'social_media_agent' to create engaging content.
        For budget queries, use the 'budget_agent' to create a budget and fill it with the data.
        For proposal queries, use the 'proposal_agent' to create a proposal.
        If you are the best to answer the question according to your description, you can answer it directly.
        When transferring tasks to sub-agents:
        - Ensure the task aligns with the agent's expertise
        - Provide clear context and requirements
        - Review and integrate their responses into a cohesive solution
        When a user provides an event planning request, you must follow this sequence:
            Acknowledge the request as the Root Agent and confirm your understanding of the event requirements.
            Activate each specialized agent in a logical order (e.g., Venue, then Budget, then catering, then social media, then proposal etc.).
            Present the output of each agent clearly under a specific heading for that agent.
            Conclude with the full Event Proposal generated by the sub agents, which ties everything together.
        If users asks to assume all the details, feel free to do so.
        """
    ),
    sub_agents=[ get_venues_agent ,catering_agent, social_media_agent, budget_agent, proposal_agent],
    generate_content_config=types.GenerateContentConfig(temperature=0.5),
)

APP_NAME = "event_planner"
USER_ID = "user123"
SESSION_ID = "session1"

session_service = InMemorySessionService()
session = session_service.create_session(app_name=APP_NAME, user_id=USER_ID, session_id=SESSION_ID)
root_agent = root_agent

runner = Runner(agent=root_agent, app_name=APP_NAME, session_service=session_service)

# Helper method to send query to the runner
def call_agent(query, session_id, user_id):
  content = types.Content(role='user', parts=[types.Part(text=query)])
  events = runner.run(
      user_id=user_id, session_id=session_id, new_message=content)

  for event in events:
      if event.is_final_response():
          final_response = event.content.parts[0].text
          print("Agent Response: ", final_response)

Running the Agent on Your Machine

Sweet! With the code all in place, let’s fire this thing up. Back in your Cloud Shell terminal (make sure you’re in the main event-planner-adk folder), just run this:

adk web

This command boots up the ADK’s local web server and gives you a simple chat page to talk to your agent. Click the URL it spits out.

Now, give it a go! Try a prompt like:

“G’day! Can you help me organise a 40th birthday party for about 50 people in Fitzroy?”

You’ll see the logs in the terminal showing the root agent calling on its sub-agents to do their bit. How cool is that!

Part 3: Sharing Your Agent with the World

Running it locally is great for building and testing, but the whole point is to make something others can use. So, let’s deploy it to Google Cloud Run, which will give us a public web address.

1. Set some environment variables. This just makes the next command a bit tidier. Run these in your Cloud Shell:

export GOOGLE_CLOUD_PROJECT=$GOOGLE_CLOUD_PROJECT_ID 
export GOOGLE_CLOUD_LOCATION=$GOOGLE_CLOUD_LOCATION 
export SERVICE_NAME=event-planner-agent 
export APP_NAME=event-planner-agent 
export AGENT_PATH=./event-planner-agent

1. Now, run the deploy command:

adk deploy cloud_run \ --project=$GOOGLE_CLOUD_PROJECT \ --region=$GOOGLE_CLOUD_LOCATION \ --service_name=$SERVICE_NAME \ --app_name=$APP_NAME \ --with_ui \ --allow-unauthenticated \ $AGENT_PATH

This command does all the heavy lifting: it packages up your agent, sends it to the cloud, and sets up a secure, scalable web service for it. It’ll take a few minutes, so go grab a cuppa.

Once it’s finished, it’ll give you a URL. Click it, and you’ll see your agent’s chat interface, now live on the internet!

Ready for the Next Step? Try Workflow Agents!

Want to stretch? Try Workflow Agents!

You’ve successfully built and deployed a powerful multi-agent system. Now, let’s take it a step further by exploring workflow agents. This feature lets you define a specific sequence for your sub-agents to follow, which can be incredibly useful for more structured tasks.

To try this out, go back to your agent.py file and uncomment the workflow_agent section. You'll find it looks like this:

workflow_agent = SequentialAgent(
    name="workflow_agent",
    description="Helps with the overall workflow of the event planning.",
    sub_agents=[get_venues_agent, catering_agent, social_media_agent, budget_agent]
)

Once uncommented, you’ll also need to integrate workflow_agent into your root_agent's sub_agents list. You can replace the existing list of individual sub-agents with workflow_agent or add it in alongside them, depending on how you want your root agent to delegate.

Give it a try and see how defining a workflow can streamline your agent’s process! What kind of structured tasks do you think a workflow agent would be perfect for in your projects?

You’ve Done It! What’s Next? 🎉

Ripper! You’ve gone from zero to a fully functional, cloud-deployed AI agent. You’ve learned the fundamentals of the ADK and built a modular system that you can easily expand and improve.

This is just the beginning. From here, you could:

• Connect to real tools: Swap out our fake functions with code that actually interacts with the Google Sheets API or a real booking system.

• Add more specialists: What about an agent for booking a DJ or another for handling legal permits?

• Refine the instructions: Tweak the prompts for your agents to make them even better at their jobs.

To keep learning, the official ADK documentation is the best place to go.

Happy building, and thanks for coming to the workshop!

Bonus: Prototyping Your Ideas First

Before you write a single line of Python, how do you know if your agent idea is any good? Give it a whirl in Google AI Studio. It’s a web-based playground where you can test prompts and model behaviour without any code.

It’s the perfect spot to draft the instruction prompts for your agents. For our event planner, I first wrote a massive "System Instruction" that described the whole agent team and how they should interact. This let me test the logic and flow of the conversation before committing it to code, which saved a heap of time. It’s a top tip for any agent-building project!

I didn’t want to deal with spinning up a Cloud Run instance, a Lambda function, deploy via Netlify, or paying to any other service. I knew there’s AWS s3 static website hosting feature but never saw the same in Google Cloud. After poking around a bit, I figured out that Google Cloud Storage (GCS) is actually perfect for this. And with a little help from Cloudflare, you can even get a custom domain with HTTPS up and running pretty quickly.

This post is my attempt to write down the steps I took — hopefully it helps you avoid some of the “wait, what?” moments I had 😅

✅ What You Need First (Pre-reqs)

• A Google Cloud account (duh)

• A project with billing turned on (they need your card, but there’s a free tier)

• Install the gcloud CLI — you’ll need this for the terminal stuff

• Your site files: index.html, maybe a style.css, some images — whatever you’ve got

• A domain name if you want to go fancy (optional but I recommend it if you’d like to learn the Cloudflare stuff)

Hosting from the GCP Console 🛠️

This is the click-click way to get your site online.

1. Create a Bucket

• Go to Cloud Storage

• Hit “Create bucket”

• Name it exactly like your domain (e.g., mycoolblog.com) if you're planning to use a custom domain later

• Choose multi-region, uniform access, skip the warning about public access (we’ll fix that next)

2. Upload Your Files

• Drag in your files or folders — make sure there’s an index.html

3. Make It Public

• Select the files

• Click Permissions → Add principal

• Add allUsers

• Give them the role Storage Object Viewer

I messed this up once by not doing it on the bucket level — so double-check where you’re applying permissions.

4. Set Website Config

• In your bucket, look for Website configuration

• Set index.html as the main page

• 404.html is optional, but it’s nice if someone hits a broken link

5. Visit Your Site

You can now open:
https://storage.googleapis.com/[your-bucket-name]/index.html

Is it the prettiest URL? No. Does it work? Absolutely.

💻 Hosting via CLI (gcloud storage)

If you’re a terminal person like me (or just lazy), the CLI is quicker.

# Make the bucket (use your domain name exact same if you're going custom)
gcloud storage buckets create gs://your-domain.com \
  --location=australia-southeast2 \
  --uniform-bucket-level-access

# Upload everything
gcloud storage cp ./your-site/* gs://your-domain.com

# Set website config
gcloud storage buckets update gs://your-domain.com \
  --web-main-page-suffix=index.html \
  --web-error-page=404.html

# Make it public
gcloud storage buckets add-iam-policy-binding gs://your-domain.com \
  --member=allUsers \
  --role=roles/storage.objectViewer

After that, boom 💥 Site’s live at:
https://storage.googleapis.com/your-domain.com/index.html

🌐 Adding Cloudflare (because HTTPS matters)

Cloudflare makes the domain + HTTPS setup painless.

1. Set Up Cloudflare

• Go to cloudflare.com, sign up, and add your domain

• It’ll ask you to switch your nameservers (do that in your domain registrar dashboard — usually under DNS settings)

2. Add a CNAME

In Cloudflare’s DNS settings:

• Name: www

• Target: c.storage.googleapis.com

• Proxy: Set to DNS-only for now

Note: This only works if your GCS bucket is named www.yourdomain.com. I tried it with a different name and… nope.

3. Enable HTTPS

• Under SSL/TLS, set mode to Flexible or Full (I used Flexible because it just worked)

• Turn on — Always Use HTTPS & Automatic HTTPS Rewrites

4. Flip the Proxy

Once everything’s working with DNS-only, go back to your CNAME and turn the orange cloud ON (a.k.a. Proxied). That gives you caching and extra speed too.

➕ What’s Next?

• Use a static site builder like Astro or Hugo if you’re tired of manually writing HTML

• Add a CI/CD pipeline (GitHub Actions works great)

• Add analytics (I’m trying out Plausible because I’m over Google Analytics)

• Share your blog on X/Twitter/LinkedIn — let people know it’s alive!

Hope you learned something out of it. If you have any better way to do this, feel free to let me know in comments or share it personally.

However, it's not all plain sailing. Developers naturally have some valid concerns, such as worries about job displacement, security risks, and the potential for AI to eat into the time they spend on truly rewarding work. This guide aims to look beyond just adopting AI and focus on how to integrate it responsibly and effectively throughout the software development lifecycle, maximising the good bits while keeping the risks in check.

How AI is Shaking Things Up for Developers

The initial news for individual developers looks largely positive:

• More Time in Flow: Developers who use gen AI more extensively report experiencing a more frequent flow state.

• Increased Job Satisfaction: They also report higher overall job satisfaction.

• Boost in Productivity: Gen AI use is linked to increased productivity. The findings suggest that a 25% increase in AI adoption by an individual could lead to an approximate 2.1% increase in productivity.

• Reduced Burnout: Interestingly, those using gen AI more also report less burnout.

However, here's where it gets a bit more complex. One of the big hopes for AI was that it would free up developers from routine tasks to focus on more valuable work. Yet, the data indicates that increased AI adoption might actually lead to less time spent on work developers consider valuable, while time spent on tedious, "toilsome" work seems to remain largely the same.

The researchers came up with the "vacuum hypothesis" to explain this. Essentially, by boosting productivity and flow, AI helps people complete valuable work more efficiently, creating extra time. However, AI isn't yet tackling those less enjoyable but still necessary tasks like meetings and bureaucracy. It's worth noting that even with this shift, developers' well-being hasn't been negatively affected.

Impact on Teams and Organisations

From an organisational standpoint, the influence of AI appears quite promising in several areas:

• A 25% increase in AI adoption is associated with a 7.5% increase in documentation quality.

• Code quality is also likely to see a 3.4% increase.

• Code review speed could improve by around 3.1%.

• Approval speed for code changes might see a modest 1.3% increase.

• Code complexity is estimated to decrease by 1.8%.

These improvements suggest that AI is helping people get more value from their codebases and documentation, and is also speeding up the code review and approval processes.

However, and this is crucial, despite these positive impacts on development processes, the findings indicate that AI adoption is negatively impacting software delivery performance. For every 25% increase in AI adoption, there's an estimated 1.5% reduction in delivery throughput and a more significant 7.2% reduction in delivery stability. The researchers hypothesise that the increased speed of code generation due to AI might be leading to larger change sizes, and as DORA research has consistently shown, larger changes are slower and more prone to instability. So, even with AI, the fundamental principles of successful software delivery, like small batch sizes, remain vital.

What Developers Truly Value in Their Work

To better understand the impact of AI on developers' perception of their work, the research delved into what developers actually consider "valuable". They identified five key perspectives:

• Utilitarian Value: The feeling that their work has a positive impact on the world. Gen AI can potentially boost this by speeding up development.

• Reputational Value: Being recognised for the work they've done. AI could increase this by improving the impact of their work, but it could also reduce it if AI gets the credit.

• Economic Value: The pay and benefits associated with their work. AI might increase this through higher productivity, but some worry about potential reductions in workforce or paid hours.

• Intrinsic Value: The inherent worthwhileness of the development work itself, often linked to learning and traditional skills. AI is anticipated to have a neutral impact as new skills like prompt engineering become important.

• Hedonistic Value: The enjoyment derived from performing certain development tasks. AI could make enjoyable tasks more accessible but might also make some obsolete. Allowing developers to choose not to use AI for tasks they enjoy is important.

Building Developers' Trust in Gen AI

For developers to embrace and benefit from AI, trust is paramount. However, research suggests that developers' trust in gen AI output is currently relatively low. Organisations can foster this trust through several strategies:

• Establish a Clear Policy on Acceptable Gen AI Use: Providing explicit guidelines encourages responsible use and can alleviate fears of unknowingly acting irresponsibly. Organisations with more transparent AI use policies see higher levels of trust.

• Double-Down on Fast, High-Quality Feedback: Robust code review and automated testing processes assure developers that errors introduced by AI-generated code will be caught. Interestingly, AI adoption can actually make code reviews faster and improve code quality.

• Provide Opportunities for Developers to Gain Exposure with Gen AI: Familiarity increases trust. This is particularly true when developers can use AI in their preferred programming languages, where they have the expertise to evaluate its output.

• Encourage Gen AI Use, But Don't Force It: While leadership encouragement is effective, developers need to maintain control over when and how AI is used. Building community structures to share knowledge organically can be a good approach.

• Help Developers Think Beyond Automation: Addressing fears of job displacement requires envisioning the future role of developers working with AI at a higher level of abstraction, focusing on innovation and user value.

Practical Strategies for Adopting Gen AI

Moving from isolated AI experiments to widespread adoption requires a strategic approach. Here are four research-backed strategies for organisations:

1. Share and Be Transparent About How Your Organisation Plans to Use AI: Open communication about the AI mission, goals, and policies can alleviate apprehension and position AI as a tool to help everyone focus on more valuable work. Organisations that do this can see an estimated 11.4% increase in team adoption of AI.

2. Address Developer Concerns About AI's Impact: Directly addressing anxieties about job displacement can enable developers to focus on learning how to best use AI. Organisations that alleviate these concerns are estimated to have 125% more team adoption of AI.

3. Allow Ample Time for Developers to Learn How to Use AI: Providing dedicated time for experimentation and integration leads to significantly higher adoption rates. Simply giving developers dedicated work time to explore AI tools can lead to a 131% increase in team AI adoption, and actively encouraging integration leads to a 27% increase.

4. Create Policies That Govern the Adoption of AI: Clear guidelines on appropriate use cases, ethical considerations, and potential risks can reduce uncertainty and encourage responsible experimentation. Organisations with AI acceptable-use policies show a 451% increase in AI adoption.

Measuring the Success of AI Adoption

To understand the impact of gen AI, it's crucial to establish baseline measurements and track progress at the team, service, and organisational levels. Some key metrics to consider include:

• Code assistant metrics: Licenses allocated, daily active users, code suggestions generated and accepted, lines of code accepted.

• Fast-feedback metrics: Tests on commit, daily tests, daily builds, test confidence, time to fix broken builds.

• Team-level metrics (gathered through surveys): AI task reliance, AI interactions, perceived AI productivity, trust in AI output, organisational trust, flow, job satisfaction, valuable work, burnout, code review time, documentation quality, technical debt.

• Service-level metrics: Code complexity, code quality.

• Organisational metrics: Customer numbers, market share, overall performance, profitability, customer satisfaction.

Gathering feedback from developers through regular surveys, team retrospectives, and communities of practice is also essential for refining the AI adoption strategy.

Key Takeaways for the Future

For Leaders:

• Prioritise transparency: Clearly communicate your AI strategy, directly address job security concerns, and establish clear policies for responsible AI use.

• Invest in your people: Provide dedicated time, training, and resources for developers to learn and experiment with AI. Foster a culture of learning and psychological safety.

• Measure and iterate: Track key metrics (code quality, developer satisfaction, delivery performance) and be prepared to adjust your approach based on data.

For Practitioners:

• Embrace experimentation: Don't be afraid to try new AI tools and explore different use cases within established guidelines.

• Become AI-fluent: Master prompt engineering, understand AI limitations, and integrate AI into your workflow.

• Own the output: Always review, test, and refine AI-generated code and documentation. Your expertise remains critical.

The integration of gen AI into software development is a significant and ongoing journey. By taking a thoughtful, data-driven, and human-centred approach, organisations and developers can collectively harness the power of AI to create a more productive, fulfilling, and innovative future.

When Your Digital Shop Has Too Many Security Guards

Imagine your website is a quirky little shop. You want to know if everything's running smoothly, right? Cloud monitoring is like having an overzealous security team with cameras everywhere and alarms that might go off when a customer sneezes too loudly. The trick is teaching your security system the difference between a real break-in and a cat walking by the window.

The Real Goal: Happy Users, Not Engineers Having Nervous Breakdowns

Good alerting isn't about getting a text message every time a server hiccups. It's about knowing when your users are having a bad time. If your website is slower than a sloth on vacation, that's alert-worthy. If a server's CPU does a little dance for two seconds? Maybe not worth the panic attack.

Think Like Your Users: What Would Make Them Rage-Quit?

Here's what deserves those dramatic alert sounds:

• Website playing dead: If your digital shop's doors are locked, you need to know ASAP before customers start the online equivalent of angrily rattling the door handles.

• Features throwing tantrums: Imagine the checkout in your shop suddenly deciding it's on strike. BEEP BEEP BEEP!

• Everything moving in slow motion: When your site takes so long to load that users can brew coffee between clicks, it's alert time.

• Error messages breeding like rabbits: If your customers keep getting digital versions of "Computer says no," they'll shop elsewhere.

The Not-So-Secret Rules of Alert Club

Focus on the Real Drama (Symptoms, Not Just Causes)

• Alert-Worthy: "Website loading time is slower than my grandma's internet connection (5+ seconds) for the last 5 minutes."

• Meh: "CPU usage on server X is above 90%." (Might be normal, might just be the server doing its workout routine.)

Set the Right "Panic Button" Level

Think about what's normal for your system. If your website usually zooms along at 2 seconds, maybe set an alert for when it starts crawling at 5 seconds.

Don't set the trigger too sensitive (like a car alarm that goes off when a butterfly lands on it) or too relaxed (like a guard dog that sleeps through an actual robbery).

Keep the Noise Down (Your Sanity Depends On It)

If the same problem keeps happening, one alert is enough—not an inbox full of "THE WEBSITE IS STILL DOWN" every 30 seconds. Modern monitoring tools let you "snooze" alerts when you're already on the case, frantically typing and chugging coffee.

Make Your Alerts Actually Helpful

Your alert should give you enough information to start fixing the problem, not just scream "SOMETHING'S WRONG!"

Good Alert Message: "Hey, the website's moving slower than a turtle in molasses. Check the application logs and the database performance dashboard before users start complaining on Twitter."

Pro Tip: Add links to helpful guides or dashboards in your alert messages. Future panicked you will thank present calm you.

Send the Alert to the Right Heroes

If it's a database problem, the database team should get the alert, not the front-end developers who can't help and will just forward it anyway. Set up different notification channels (email, Slack, SMS) and send alerts to specific teams.

Alert Types for Mere Mortals

• Metric Alerts: These watch numbers like your website's vital signs—CPU usage, error counts, response times.

• Log Alerts: These scan your logs for concerning words like "ERROR" or "CRITICAL FAILURE" or "OH NO OH NO OH NO."

• SLO Alerts: These are for the overachievers. They help track if you're keeping your promises to users about reliability.

A Real-Life Adventure Tale

Let's say you run an online shop selling artisanal cloud-shaped pillows. You want to know if people can't add items to their cart.

1. User Impact Assessment: Users can't buy your fluffy cloud pillows! Red alert!

2. Metric Selection: Monitor the number of errors on the "add to cart" function.

3. Threshold Setting: If errors exceed 5 in a minute, something's definitely wrong.

4. Alert Creation: Set up a metric-based alert in your monitoring system.

5. Notification Setup: Configure alerts to ping your support team on Slack with the message: "MAYDAY! MAYDAY! Cart function is broken! Cloud pillows are not being sold!"

6. Helpful Context: Include a link to the logs so the team can start investigating immediately.

Keep Evolving Your Alert Game

Just like you'd adjust security in your shop over time (maybe that motion sensor in the bathroom wasn't the best idea), review your alerts regularly. Getting woken up at 3 AM for non-issues? Time to adjust those thresholds. Missing actual problems? Maybe tighten things up a bit.

The TL;DR for the Alert-Fatigued

Good alerting is about setting up smart alarms that tell you about real problems your users are facing, without making you want to throw your phone into the sea. Focus on what matters to your users, set sensible triggers, and make sure your alerts give you the information you need to fix things quickly.

Remember, in the world of cloud monitoring, beep happens—but it doesn't have to happen constantly!

Innovation at the Forefront:

The website, cloud.withgoogle.com/next/25, hints at a focus on cutting-edge innovations that are driving the future of cloud. Expect deep dives into:

• Artificial Intelligence and Machine Learning: Google Cloud is a leader in AI, and Next '25 will undoubtedly showcase the latest advancements. Look out for sessions on generative AI, responsible AI practices, and how businesses can leverage AI to transform their operations.

• Data Analytics and Management: In today's data-driven world, efficient data management is crucial. Expect to see updates on Google Cloud's data analytics tools, including BigQuery, Dataflow, and Dataproc.

• Infrastructure and Security: As businesses increasingly rely on the cloud, robust infrastructure and security are paramount. Next '25 will likely feature sessions on scalable infrastructure, cybersecurity best practices, and innovative security solutions.

• Application Modernization: Modernizing applications is key to staying competitive. Expect to see how google cloud assists with containerization, serverless computing, and microservices.

• Collaboration and Productivity: Google Workspace integration with cloud services will likely be a highlight, demonstrating how teams can work more efficiently and collaboratively.

A Platform for Learning and Networking:

Google Cloud Next '25 is more than just a showcase of technology; it's a platform for learning. Expect:

• Keynote Presentations: Hear from Google Cloud leaders and industry experts about the latest trends and vision for the future of cloud computing.

• Breakout Sessions and Workshops: Dive deep into specific topics and gain hands-on experience with Google Cloud technologies.

• Hands-on Labs: Test drive the newest google cloud products.

• Networking Opportunities: Connect with fellow cloud professionals, Google Cloud partners, and experts.

• Partner Showcases: Explore innovative solutions from Google Cloud's extensive partner ecosystem.

Why Attend Google Cloud Next '25?

• Stay Informed: Keep up with the latest cloud trends and technologies.

• Gain Practical Skills: Learn from experts and gain hands-on experience.

• Network with Industry Leaders: Connect with peers, partners, and Google Cloud experts.

• Discover Innovative Solutions: Explore new ways to leverage the cloud to drive business growth.

Mark Your Calendars: April 9-11, 2025

While specific details are still emerging, the excitement is building for Google Cloud Next '25. Keep an eye on the official website for updates on registration, agenda, and speakers.

Whether you're a seasoned cloud professional or just starting your cloud journey, Google Cloud Next '25 promises to be an event that will inspire and empower you to innovate.

Since its establishment, Wiz has been recognized for developing cloud security platforms that address complex cybersecurity challenges faced by modern businesses. Wiz's products are known for their compatibility across various cloud environments, providing users with visibility and security control.

According to statements from both companies, the acquisition aligns with their shared vision of integrating development and security functions more closely. Wiz will continue to support multiple cloud providers, including AWS, Azure, and Oracle Cloud Infrastructure (OCI), maintaining its existing partnerships.

Google aims to enhance its cloud security offerings through this acquisition, leveraging Wiz’s capabilities alongside Google's expertise in artificial intelligence, data analytics, and popular technologies such as Kubernetes and TensorFlow. Additionally, Google's acquisition of cybersecurity firm Mandiant in 2022 is expected to complement Wiz’s security operations and threat intelligence capabilities.

The companies have indicated that Wiz will retain operational independence, continuing to serve existing customers without disruption.

The acquisition marks a significant development in the cloud security sector, underscoring the growing importance of cybersecurity solutions in enterprise technology.

This new setup offers some great advantages:

Having a Google Cloud region in Sweden means that data can be stored and processed locally. This is a big deal for companies that need to keep their information within the country. Plus, Google is aiming for this region to be very environmentally friendly by using mostly carbon-free energy .

One of the best things about this new region is speed. With data centers closer to users in Sweden, things online will feel much faster. Even a tiny bit of speed can make a big difference! As Tyson Singer from Spotify said, "...even milliseconds matter, the new Google Cloud region in Sweden will be a catalyst for accelerating innovation..." .

Businesses are already seeing the positive impact. Linus Sjöberg, CTO of Tradera, mentioned that Google Cloud's technology has helped them improve their customer's selling experience .

In short, Google Cloud's arrival in Sweden is a major step forward for the country's digital future. It brings faster, greener, and more secure cloud services closer to home, helping Swedish innovation thrive.