Building Three AI Agents in a Week: My Google Cloud Gen AI Academy APAC Journey

When I signed up for the Google Cloud Gen AI Academy APAC Edition (run with Hack2Skill), I honestly didn't know how far I'd get. By the end, I had built and deployed three working AI agents on Google Cloud — a conversational barista, a data analyst that writes its own SQL, and a productivity assistant that manages a spreadsheet on my behalf. Here's the story of what I built, how it works, and what I learned along the way (including the walls I hit and how I got past them).

What the Academy is about

The Gen AI Academy APAC follows a hands-on, challenge-based model: you learn a concept, then build something real with it. It's organized into three tracks, each a codelab that ends with a live application deployed to Google Cloud Run. The common toolkit across all three:

• Google Agent Development Kit (ADK) — the framework for building AI agents
• Gemini — the model doing the reasoning
• Cloud Run — serverless hosting, so each agent ends up as a public URL
• BigQuery, MCP, Cloud Run Sandboxes, Google Sheets — depending on the track

Let me walk through each one.

Track 1 — The AI Barista (RAG on Cloud Run)

What I built: A friendly coffee-shop assistant that recommends drinks and pastries based on what a customer asks for — and, crucially, only recommends things that are actually on the menu.

How it works: The agent is an ADK LlmAgent powered by Gemini. Instead of hardcoding the menu into the prompt, it calls a tool (get_menu()) that reads the menu data at runtime. This is a simple form of Retrieval-Augmented Generation (RAG) — the agent grounds its answers in real data rather than making things up. A Streamlit chat interface wraps it, and the whole thing is deployed to Cloud Run.

Why the grounding matters: I tested it three ways:

• Ask for "something strong and hot" → it recommends a real menu item (Espresso)
• Ask for a "matcha frappuccino" (not on the menu) → it politely declines instead of inventing one
• Say "I'm lactose intolerant" → it recommends only dairy-free items

That last test taught me something. My first build had a subtle bug: the code canonicalized the customer's wording ("no gluten") but not the menu's allergen labels ("wheat") — so a coeliac could have been offered a wheat croissant. Fixing that (canonicalizing both sides) was my first real lesson in how AI grounding can quietly go wrong.

Stack: ADK · Gemini · RAG · Streamlit · Cloud Run

Track 2 — The BigQuery Data Agent (text-to-SQL with MCP)

What I built: An agent that answers business questions by querying real data. The scenario: "We have budget for 3 coffee trucks — find the best city bike stations to place them." The agent figures out the answer from live data.

How it works: This one connects Gemini to Google BigQuery through the BigQuery MCP Server. MCP (Model Context Protocol) is an open standard that lets an agent call external tools in a uniform way — here, tools to list tables, inspect schemas, and run read-only SQL. I pointed it at the public NYC Citibike dataset.

When I asked the coffee-truck question, the agent did something genuinely impressive on its own: it reasoned that morning commuters were the target, picked a 6–10 AM window, wrote SQL to count trips per station in that window, and returned the three busiest stations with their trip counts. I never wrote a line of that SQL — the agent did.

The safety detail I liked: the agent is restricted to read-only BigQuery tools. It can explore and analyze, but it can never modify or delete data. That guarantee is built into the tool configuration, not just requested in the prompt.

A debugging story: the deployed version initially kept saying it "couldn't retrieve the results," even though the same code worked locally. Reading the Cloud Run logs showed the queries were running (mostly 200 OK) with an occasional 400 — meaning it was writing an invalid query and giving up, not a permissions problem. Redeploying with a fresh instance, plus asking with a more explicit query, resolved it. Lesson: the logs tell the real story; the chat UI only shows the polite summary.

Stack: ADK · Gemini · BigQuery · MCP · Cloud Run

Track 3 — The Productivity Agent (sandboxed code + human-in-the-loop)

What I built: A coffee-shop operations assistant for graduation weekend — the busiest period of the year. It reads last year's point-of-sale data from a Google Sheet, predicts this year's demand spikes against the ceremony schedule, recommends staffing and inventory changes, and — with my approval — writes a TODO list back into the spreadsheet.

How it works: This was the most sophisticated of the three. The agent has four tools: run code in a sandbox, read a sheet, write a sheet, and create a new tab. Two things make it special:

• Cloud Run Sandbox — when the agent needs to crunch numbers, it writes its own Python code and runs it inside a secure, isolated sandbox. Self-generated code runs contained, with no risk to the host.
• Human-in-the-loop — the agent never edits my spreadsheet without asking. It presents its findings, asks permission, and only writes after I say "yes."

A WebSocket chat UI keeps a live connection open so the agent can stream its thinking through the multi-step task. When I gave it the graduation schedule, it correlated last year's demand spikes (cold brew, extra espresso, alt milk) with the ceremonies that caused them, predicted when this year's rushes would hit, diagnosed whether each bottleneck was a cashier or a barista problem, and proposed specific staffing tasks — then wrote them to a TODO tab once I approved.

Stack: ADK · Gemini · Cloud Run Sandbox · Google Sheets API · WebSockets

What I actually learned

Beyond the frameworks, the real lessons were the unglamorous ones:

• IAM and permissions are half the battle. I hit 403 errors on both Track 1 and Track 2. The fix was almost always granting the right role to the right service account — and then waiting for it to propagate.
• Environment variables and sessions reset. Cloud Shell forgetting my exported variables after a page reload cost me real time until I learned to save them and re-source them.
• Read the logs, not the chatbot. The agent's polite "I couldn't do that" hid the actual error every time. The truth was in the Cloud Run logs.
• Grounding is subtle. The allergen bug in Track 1 showed me that "the AI answered from real data" isn't the same as "the AI answered correctly" — the data plumbing has to be right too.
• *Least privilege and human-in-the-loop aren't optional niceties. * Read-only tools and approval gates are what make an agent safe to actually deploy.

Where I go from here

I'll be honest: I built a lot of this with heavy assistance, and I want to genuinely understand every line. So my next step is to rebuild these projects more independently — starting by annotating my own code, then building a RAG chatbot from scratch, and deepening my Python, SQL, and cloud fundamentals. The Academy gave me something most tutorials don't: three real, deployed applications to learn from, not just watch.

If you're on the fence about doing something like this — build the thing, break it, fix it, and write about it. That loop taught me more in a week than months of passive learning.

Built during the Google Cloud Gen AI Academy APAC Edition (Hack2Skill). Agents built with Google ADK, Gemini, BigQuery, MCP, and Cloud Run.