Skip to content

Build Your Investor Hunter AI Agent with ADK

Introduction and Setup

In this workshop, you will build an enterprise-grade, Multi-Agent AI system designed to help you bulletproof your startup. Using the Google Agent Development Kit (ADK) and the latest Gemini 3.x models, you will build a "Virtual Board of Advisors" that stress-tests your pitch, validates market assumptions against proprietary reports, pulls live financial comparables, connects to BigQuery data warehouses via MCP, and runs automated model benchmarking.

Depending on your experience with building agents, Python, and Google Cloud, you can choose to follow this workshop in one of 3 ways:

  • Build from scratch: Use instructions & hints to write your own code.
  • Vibe code: Build with instructions using your favourite AI Code assistant tool (such as Google's Antigravity CLI).
  • Inspect & modify: Use the provided complete code solutions (& amend them to your liking).

🗺️ Workshop Roadmap

Level / Track Focus Area What You Will Build & Learn
Level 1 The Brutal Honest Advocate Build your core pitch critique agent, configure system instructions, and master automated HTTP retries.
Level 2 Grounding with Vertex AI Search Connect Gemini Enterprise Agent Platform (GEAP) to proprietary Cloud Storage data stores and pitch deck PDFs.
Level 3 Multi-Agent Pipelines & ADK 2.x Orchestrate concurrent ParallelAgent advisors, sequential synthesis pipelines, and live financial market tools (yfinance).
Level 4 Memory & Session Persistence Implement conversational memory and state management across multi-turn pitch discussions.
Level 5 Cloud Run Deployment Package your multi-agent system in Docker, isolate credentials, and deploy to serverless Cloud Run with spend caps (--max-instances=3).
Level 6 Security & Governance Guidance Production architecture best practices: hard spend caps, instance limits, secure ingress (IAP), and guidance on Google Cloud Model Armor.
🌟 Bonus 1 Interactive VC Sparring Partner Turn your agent into a live, multi-turn Y Combinator partner simulation that grills unit economics turn-by-turn.
🌟 Bonus 2 Batch Due Diligence Pipeline Process bulk startup applications asynchronously at 50% cost savings using the Gemini Batch API.
🌟 Bonus 3 BigQuery Analytics via MCP Connect ADK to Google BigQuery via the Model Context Protocol (McpToolset) to query empirical deal benchmarks.
🌟 Bonus 4 Multi-Model Evaluation & LLM-as-a-Judge Benchmark gemini-3.5-flash-lite, gemini-3.7-flash, and gemini-3.1-pro-preview with automated Pydantic judge scorecards and adk eval.

Two Production-Ready Paths: Google AI Studio vs. Gemini Enterprise Agent Platform

Google provides two first-class ways to build and deploy GenAI agents:

  1. Google AI Studio (Gemini Developer API): Direct, developer-centric API access with free tiers and Pay-As-You-Go production billing. Ideal for rapid prototyping, standalone apps, or cross-cloud architectures.
  2. Gemini Enterprise Agent Platform (GEAP / Google Cloud): Designed for deep enterprise integration within Google Cloud (for example: Cloud Storage, Enterprise Search Data Stores, IAM security governance, VPC Service Controls, BigQuery, and Cloud Run).

In this workshop, you will start with Google AI Studio for instant zero-friction setup in Level 1, and seamlessly connect to Gemini Enterprise Agent Platform (Google Cloud) as you incorporate Cloud Storage data stores, BigQuery MCP, and serverless Cloud Run deployments.

Prerequisites

  1. Open Google Cloud Shell (or your local terminal/IDE). You can use your own Google Cloud Project or one provided by the workshop organizers.

  2. Obtain a Google AI Studio API Key (for Level 1):

    • Go to Google AI Studio and log in with your Google account.
    • Click Get API key on the left-hand sidebar (bottom of the screen).
    • Click Create API key (create in a new project or select your workshop project).
    • Copy and save your key securely.

    Security & Billing Notes

    • Security: Never hard-code API keys directly into public repositories (like GitHub). Use environment variables instead.
    • Billing: The default Free Tier has generous rate limits for testing. You can enable Pay-As-You-Go on your AI Studio account for higher production throughput. When using workshop-provided accounts, quotas are already configured.
    • In AI Studio you can set Spend Cap on each API key you have created - be sure to set it when working on your own environment.
    • If you are an individual developer, you can choose a prepay billing for Gemini API usage while using AI Studio.

  3. In Google Cloud Shell or your local terminal, create a Python virtual environment and install dependencies:

    • Linux / macOS / Cloud Shell: 
      python3 -m venv .venv
source .venv/bin/activate
pip install google-adk "mcp==1.26.0" google-cloud-discoveryengine yfinance pydantic python-dotenv
    • Windows: 
      python -m venv .venv
.\.venv\Scripts\activate
pip install google-adk "mcp==1.26.0" google-cloud-discoveryengine yfinance pydantic python-dotenv

  4. Verify your ADK environment setup: 

    python3 -c 'import google.adk; print("🚀 ADK Environment Ready!")'

Initialize ADK Project

Run the following commands to create your ADK project structure:

# Select: telemetry: n; Option 1 for the next two ADK prompts, then provide your Google AI Studio API key
adk create investor_hunter

All your code will live inside agent.py in your newly created investor_hunter folder. Inspect the created folder—notice the .env file where your API key and environment variables are stored. (In Cloud Shell, click View -> Toggle hidden files if needed).

Level 1: The Brutal Honest Advocate ⏱️ 15 mins

Your first task is to build the core of your advisory board. This agent acts as a "Devil's Advocate"—it finds every hole in your business model before a real investor does.

Task

Open agent.py and configure the root_agent to be your toughest critic.

Code Instructions

  1. Make sure Agent class is imported from google.adk.agents, and Gemini with types from google.adk.models.google_llm and google.genai.
  2. Configure automatic retries with HttpRetryOptions to handle transient rate limits gracefully.
  3. Define root_agent. Give it an instruction telling it to be a skeptical, high-level consultant. Check out the guide on how to write good prompts.
  4. Focus its critiques on: Burn rate, Unit Economics, and Moat.

  5. Experiment with models—set by changing the model variable (you already selected a model when you used adk create command, feel free to start with the default first):

    • gemini-3.7-flash (balanced speed and reasoning)
    • gemini-3.5-flash-lite (ultra-fast, high-throughput)
    • gemini-3.1-pro-preview (deep reasoning)

You can check all available models (from Google and partners) in the docs.

💡 Need a hint? You can read more about agent structure, in particular LLM agents, in the ADK documentation.


Example Code Solution

📁 File: investor_hunter/agent.py
from google.adk.agents import Agent
from google.adk.models.google_llm import Gemini
from google.genai import types

# ==========================================
# LEVEL 1: THE BRUTAL DEVIL'S ADVOCATE
# ==========================================

# Configure the model with automatic retries to absorb transient rate limits
model = Gemini(
    model="gemini-3.7-flash",
    retry_options=types.HttpRetryOptions(initial_delay=2, attempts=3)
)

root_agent = Agent(
    name="devils_advocate",
    model=model,
    instruction=(
        "You are a skeptical startup advisor and a brutal devil's advocate. "
        "Your goal is to stress-test the founder's idea by finding flaws in their "
        "business model. Focus on burn rate, competition, and 'moats' (defensibility). "
        "Be concise, direct, and do not hold back on criticism. "
        "Be fair - if the idea is good, acknowledge its strengths."
    )
)

Test It

Run the following command in your terminal:

adk web

If the command above does not work for you, try: 

adk web --allow_origins "*"

Open the provided localhost link and type your prompt, for example:

  • I am launching a premium cat toy subscription box. We have $500k in funding and plan to spend $400k on influencer marketing in month one to acquire users fast. (Expected behavior: The agent should ruthlessly attack the unsustainable customer acquisition cost.)

  • I'm building an app that connects dog owners with local parks. We will win because our UI is slightly better than Google Maps. (Expected behavior: The agent should point out the lack of defensibility.)

Note on Terminal Advisory Warnings

When running adk web, you may notice an informational log in your terminal: Direct use of automatic function calling (AFC) in AsyncModels.generate_content is not recommended....

This is an internal advisory between the low-level google-genai library and the ADK orchestration runtime. It is completely benign and does not affect execution—your agent will respond and stream output normally.

🛡️ Production Masterclass: Handling 429 Errors & Scaling Throughput

When scaling GenAI agents to production, you will encounter concurrency spikes and rate limits (429 Resource Exhausted). Here is how production architectures address them:

  1. Exponential Backoff with Jitter: Configure types.HttpRetryOptions(initial_delay=2, attempts=3) as shown above. When many users hit your agent simultaneously, automatic retries with exponential backoff absorb momentary quota spikes without failing user requests.
  2. Model Tiering (Flash vs. Pro): Route high-frequency background agent tasks to fast, lightweight models like gemini-3.5-flash-lite, reserving larger models (like gemini-3.7-flash or gemini-3.1-pro-preview) for deep reasoning and final synthesis.
  3. Pay-As-You-Go vs. Priority Pay-As-You-Go: Standard Pay-As-You-Go provides pay-per-token pricing with dynamic shared capacity. Priority Pay-As-You-Go provides prioritized request queueing and enhanced availability under high platform load for latency-sensitive applications.
  4. Provisioned Throughput (PT): For mission-critical enterprise applications with predictable high volumes, Provisioned Throughput allows you to reserve dedicated model capacity. It provides guaranteed throughput, latency SLAs, and zero throttling.
  5. Asynchronous Batch API (50% Cost Savings): Not everything needs to be real-time! If you need to analyze 100 pitch decks or evaluate thousands of customer feedback entries overnight, use the Gemini Batch API (client.batches.create). Batch jobs run asynchronously in the background at 50% of the standard token cost and bypass real-time interactive rate limits completely.

Level 2: The Market Truth-Seeker — Grounding & RAG ⏱️ 20 mins

It is easy to fall into the trap of "market optimism." In this level, you will ground your agents in verified market research reports.

We will use Gemini Enterprise Agent Platform (GEAP) on Google Cloud (formerly known under the Vertex AI suite). Grounding models with RAG (Retrieval-Augmented Generation) prevents hallucinations and ensures your pitch critiques are backed by hard data. See sample mock data here (copy, paste & save as market_research.txt or generate your own).

Understanding Branding vs. Code Identifiers

In the Google Cloud Console, the product is branded as Gemini Enterprise Agent Platform (under AI Applications / Data Stores). In the Python SDK, IAM roles, and CLI commands, standard technical identifiers are used:

  • SDK Tools: DiscoveryEngineSearchTool or VertexAiSearchTool (both imported from google.adk.tools)
  • Environment Variable: GOOGLE_GENAI_USE_ENTERPRISE=True
  • IAM Roles: roles/aiplatform.user and roles/discoveryengine.viewer

Task

Create a researcher_agent that uses DiscoveryEngineSearchTool to verify your market size and competition claims.

Step 1: Create Cloud Storage Bucket & Data Store

  1. In a new tab, open the Google Cloud Console (use provided credentials or your project).
  2. Go to Cloud Storage -> Click Create bucket (choose a globally unique name, select Region matching your location, and keep default settings). Note your bucket name.
  3. Upload your market_research.txt file (with data from here).
  4. In the Console search bar, search for AI Applications (or Agent Builder / Discovery Engine). If prompted, click the blue button Continue and activate the API.
  5. Select Data Stores in the left-hand navigation and click Create data store. Select Cloud Storage, select the bucket you created, and name your data store pitch-war-room-data.
  6. Click Create. Indexing begins in the background (typically taking a few minutes). You can check the Activity tab to verify when processing completes.
  7. Copy your Data Store ID from the console—you will need it in your code.

Step 2: Switch to Google Cloud Authentication

Update your .env file in the investor_hunter folder:

📁 File: investor_hunter/.env
GOOGLE_GENAI_USE_ENTERPRISE=True
GOOGLE_CLOUD_PROJECT="your-google-cloud-project-id"
GOOGLE_CLOUD_LOCATION="global"  # Or your selected region

Authenticate from your terminal using Application Default Credentials (ADC): 

gcloud auth application-default login

💡 Need a hint? You can learn more about grounding agents with Data Stores in the ADK Grounding Documentation.


Example Code Solution

📁 File: investor_hunter/agent.py
import os
from google.adk.agents import Agent
from google.adk.tools import DiscoveryEngineSearchTool, google_search
from google.adk.models.google_llm import Gemini
from google.genai import types

# ==========================================
# LEVEL 2 CONFIGURATION
# ==========================================
# Make sure to substitute YOUR_PROJECT_ID and YOUR_DATASTORE_ID
DATASTORE_PATH = "projects/YOUR_PROJECT_ID/locations/global/collections/default_collection/dataStores/YOUR_DATASTORE_ID"

# 1. Initialize Grounding Tools: Internal RAG + Live Web Search
private_rag_tool = DiscoveryEngineSearchTool(data_store_id=DATASTORE_PATH)
live_web_tool = google_search  # ADK built-in Google Search tool

# 2. Configure Model with Auto-Retries
model = Gemini(
    model="gemini-3.7-flash",
    retry_options=types.HttpRetryOptions(initial_delay=2, attempts=3)
)

# 3. Define the Dual-Grounded Market Researcher Agent
root_agent = Agent(
    name="market_truth_seeker",
    model=model,
    instruction=(
        "You are a data-driven market researcher. Your job is to verify startup "
        "market claims.\n"
        "- Use the private Data Store tool to verify claims against internal reports.\n"
        "- Use Google Search to check the live web for recent competitor funding announcements, "
        "new product launches, or recent market trends.\n"
        "If a founder claims a market size or trend that contradicts the data, correct them "
        "immediately with facts. Be concise, objective, and factual."
    ),
    tools=[private_rag_tool, live_web_tool]
)

Test It

Restart your ADK web server (CTRL+C then adk web again) and ask your questions:

  • "Summarize the key barriers to entry in the pet-tech market according to the Q1 2026 internal report." (Tests private Data Store RAG)
  • "Did Tractive or any other pet GPS tracker raise new funding or launch new products recently?" (Tests live Google Search Grounding)
  • "I am launching a new smart collar with a $15/month subscription. I project we will capture 20% of the $100 Billion global pet tech market." (Expected behavior: The agent corrects you on two fronts: the market is only $19.98 Billion, and 65% of owners refuse subscriptions over $9.99/month.)

Level 3: The Ultimate Pitch Coach — ADK 2.x Multi-Agent Pipeline ⏱️ 25 mins

A complete pitch review requires multiple perspectives: market validation, financial comparison, and strategic critique.

In ADK 2.x, rather than relying solely on stochastic, back-and-forth conversational polling, you build Deterministic Multi-Agent Pipelines:

  1. ParallelAgent (Concurrent Research): Triggers your Market Truth-Seeker and Valuation Analyst at the exact same moment in parallel, cutting response latency in half.
  2. SequentialAgent (Deterministic Pipeline): Chains the concurrent findings directly into your Lead Pitch Coach for structured synthesis and strategic critique.
graph TD
    User["Founder Pitch Prompt"] --> Pipe["SequentialAgent: pitch_pipeline"]

    subgraph Sub1["ParallelAgent: advisory_board (Concurrent Execution)"]
        Researcher["Market Truth-Seeker<br/>Data Store RAG + Google Search"]
        Analyst["Valuation Analyst<br/>Live yfinance Tool"]
    end

    Pipe --> Researcher
    Pipe --> Analyst

    Researcher --> Lead["Lead Pitch Coach Agent<br/>Synthesizes Grounded Teardown"]
    Analyst --> Lead

    Lead --> Output["Complete Pitch Critique & Reality Check"]

Task

Construct an ADK 2.x workflow pipeline where a ParallelAgent coordinates the specialist advisors and feeds results into the SequentialAgent lead synthesizer.

Instructions

  1. Create a Python tool using yfinance to fetch live Market Caps.
  2. Initialize the specialized market_truth_seeker and valuation_analyst agents.
  3. Combine them into an advisory_board using ParallelAgent(name="advisors", sub_agents=[...]).
  4. Wrap the advisory_board and pitch_coach_lead into the root SequentialAgent(name="pitch_pipeline", sub_agents=[...]).
💡 Need a hint on ADK 2.x workflows? In ADK 2.x, `ParallelAgent` executes its `sub_agents` concurrently and aggregates their findings, while `SequentialAgent` passes data through each step in a predictable sequence. Check out the ADK Multi-Agent Documentation.


Full Example Code Solution

📁 File: investor_hunter/agent.py
import os
import yfinance as yf
from google.adk.agents import Agent, ParallelAgent, SequentialAgent
from google.adk.tools import DiscoveryEngineSearchTool, google_search
from google.adk.models.google_llm import Gemini
from google.genai import types

# ==========================================
# 1. CONFIGURATION & SHARED MODEL
# ==========================================
DATASTORE_PATH = "projects/YOUR_PROJECT_ID/locations/global/collections/default_collection/dataStores/YOUR_DATASTORE_ID"

# Shared model with retry backoff for all agents
shared_model = Gemini(
    model="gemini-3.7-flash",
    retry_options=types.HttpRetryOptions(initial_delay=2, attempts=3)
)

# ==========================================
# 2. TOOLS
# ==========================================

# 1. Internal Market Research RAG Tool
search_tool = DiscoveryEngineSearchTool(data_store_id=DATASTORE_PATH)

# 2. Live Financial Valuation Tool
def get_competitor_valuation(ticker_symbol: str) -> str:
    """
    Fetches the live market capitalization of a publicly traded competitor.
    Args:
        ticker_symbol (str): The stock ticker (e.g., 'UBER', 'CHWY', 'AAPL').
    """
    try:
        stock = yf.Ticker(ticker_symbol)
        info = stock.info
        cap = info.get('marketCap')
        name = info.get('shortName', ticker_symbol)
        if cap:
            return f"{name} ({ticker_symbol}) has a live market cap of ${cap:,}."
        return f"Could not find valuation for {ticker_symbol}."
    except Exception as e:
        return f"Financial data error: {str(e)}"

# ==========================================
# 3. SPECIALIST AGENTS
# ==========================================

# Market Research Sub-Agent
researcher_agent = Agent(
    name="market_truth_seeker",
    model=shared_model,
    instruction=(
        "You are a cynical market researcher. Validate the founder's market size and competition claims "
        "against internal reports and live Google Search. Return concrete, grounded data points."
    ),
    tools=[search_tool, google_search]
)

# Financial Valuation Sub-Agent
analyst_agent = Agent(
    name="valuation_analyst",
    model=shared_model,
    instruction=(
        "You are a financial valuation analyst. Look up live market valuations "
        "of public competitor companies using their stock tickers and return exact numbers."
    ),
    tools=[get_competitor_valuation]
)

# Synthesis Lead Coach Agent
lead_coach = Agent(
    name="pitch_coach_lead",
    model=shared_model,
    instruction=(
        "You are the Lead Pitch Coach. Synthesize the findings from your advisory board into a structured review:\n"
        "1. **Market Reality Check**: Verified market metrics and competitor landscape from the researcher.\n"
        "2. **Valuation Reality Check**: Live competitor market caps and public benchmark data.\n"
        "3. **Devil's Advocate Critique**: Tough assessment of their moat, burn rate, and unit economics."
    )
)

# ==========================================
# 4. ADK 2.x DETERMINISTIC WORKFLOW PIPELINE
# ==========================================

# Step A: Run both specialist advisors concurrently in parallel
advisory_board = ParallelAgent(
    name="advisory_board",
    sub_agents=[researcher_agent, analyst_agent]
)

# Step B: Chain the parallel advisors into the synthesis lead coach
root_agent = SequentialAgent(
    name="pitch_pipeline",
    sub_agents=[advisory_board, lead_coach]
)

Test It

Restart your ADK web server (CTRL+C & adk web). Pitch your startup to the coach. Ask it to verify your market assumptions and check the live valuation of a public competitor.

Example prompts:

  • I am pitching a direct-to-consumer premium smart dog collar brand. I assume our total addressable market is at least $50 Billion. My goal is to eventually reach the scale and valuation of Chewy (CHWY). What do you think of this plan?

Understanding the Performance Alert: Context Cache Alignment in Multi-Agent Pipelines

When testing your Level 3 pipeline, you may see an informational performance alert:

Performance Alert: System instructions were modified between consecutive turns in this session. This change breaks context cache alignment, resulting in a cache miss...

Why this happens:

  • Gemini automatically caches prompt prefixes (System Instructions → Conversation History) across turns to accelerate Time-to-First-Token.
  • In Level 3, three distinct agents execute in the same pipeline session: market_truth_seeker, valuation_analyst, and pitch_coach_lead.
  • Because each specialist agent has a different system instruction tailored to its specific role, the system instruction prefix changes between agent steps within the same session.
  • Gemini's cache manager simply notes that it will compute a fresh prompt pass for each specialist rather than reusing a cached prefix from a different agent.

Is anything broken?

  • No. The pipeline executes completely normally, all tools fire, and the final synthesis is generated. In role-specialized multi-agent architectures, cache misses between distinct specialist agents are completely normal and expected.

Level 4: Multimodal Pitch Deck Analyzer & Structured Investment Memo ⏱️ 15 mins

Real investors don't just read chat messages—they review 10-slide pitch decks (PDFs) and generate formal, typed Due Diligence Memos.

In this level, you will:

  1. Analyze Pitch Decks Multimodally: Leverage Gemini's native PDF document understanding to inspect slide clarity, narrative flow, and financial transparency.
  2. Enforce Structured Outputs: Use Pydantic schemas and response_schema to produce a deterministic, machine-readable Investment Memo & Readiness Scorecard.
graph TD
    PDF["Pitch Deck PDF or Pitch Text"] --> Coach["Structured Pitch Coach Agent"]
    Coach --> Schema["Pydantic Response Schema"]
    Schema --> JSON["JSON Investment Memo & Scorecard<br/>• Verdict: INVEST / PASS<br/>• Score: 1-10<br/>• TAM Reality Check<br/>• Key Red Flags"]

Task

Define an InvestmentMemo Pydantic model and configure your Lead Coach agent to return structured JSON data.

Example Code Solution

📁 File: investor_hunter/agent.py
from pydantic import BaseModel, Field
from google.adk.agents import Agent
from google.adk.models.google_llm import Gemini
from google.genai import types

# ==========================================
# 1. DEFINE THE STRUCTURED INVESTMENT MEMO
# ==========================================
class InvestmentMemo(BaseModel):
    startup_name: str = Field(description="Name of the startup or pitch concept")
    verdict: str = Field(description="One of: 'INVEST', 'INVESTIGATE FURTHER', or 'PASS'")
    readiness_score: int = Field(ge=1, le=10, description="Overall investor readiness score from 1 (unprepared) to 10 (deal-ready)")
    tam_reality_check: str = Field(description="Critique of their market size claims against realistic industry data")
    competitor_valuation_check: str = Field(description="Comparison to public competitor market capitalizations")
    key_red_flags: list[str] = Field(description="Top 3-5 critical risks, unit economic flaws, or lack of moats")
    actionable_recommendations: list[str] = Field(description="Concrete steps the founders must take to fix their pitch")

# ==========================================
# 2. CONFIGURE STRUCTURED OUTPUT MODEL
# ==========================================
structured_model = Gemini(
    model="gemini-3.7-flash",
    retry_options=types.HttpRetryOptions(initial_delay=2, attempts=3),
    generate_content_config=types.GenerateContentConfig(
        response_mime_type="application/json",
        response_schema=InvestmentMemo
    )
)

# ==========================================
# 3. DEFINE STRUCTURED COACH AGENT
# ==========================================
root_agent = Agent(
    name="structured_pitch_evaluator",
    model=structured_model,
    instruction=(
        "You are an institutional venture capital partner evaluating early-stage pitches. "
        "Analyze the provided pitch or pitch deck thoroughly. "
        "Evaluate defensibility, burn rate, unit economics, market size, and public comparables. "
        "Return your evaluation strictly conforming to the InvestmentMemo JSON schema."
    )
)

Test It

Restart adk web and test your structured agent:

  • Submit your startup pitch or upload a PDF pitch deck in the chat interface. (An example PDF can be obtained from workshop organisers, or you can try generating your own with your favourite AI tool - you can check out Gemini app if you haven't tried it yet.)
  • Notice that instead of unstructured conversational text, the agent returns a typed, deterministic JSON object ready to be stored in a database, CRM, or rendered into a client-facing PDF scorecard!

Level 5: Deploying to Cloud Run — Going Live ⏱️ 20 mins

Your Pitch Coach works locally, but a real product needs to live in the cloud. In this final step, you will containerize your ADK application and deploy it to Google Cloud Run so it is accessible over HTTPS from anywhere.

Task

Enable the necessary Google Cloud APIs, create the deployment files (requirements.txt, .dockerignore, and Dockerfile), and deploy your agent using Google Cloud CLI.

Step 1: Enable Google Cloud APIs

To build and host your container, enable the required APIs:

gcloud services enable \
  run.googleapis.com \
  cloudbuild.googleapis.com \
  artifactregistry.googleapis.com

Step 2: Prepare Requirements

Create a new file named requirements.txt in your investor_hunter project folder:

📁 File: investor_hunter/requirements.txt
google-adk
google-cloud-discoveryengine
yfinance
pydantic

Step 3: Create a .dockerignore File

Before creating the Dockerfile, ensure you do not upload local virtual environments, cache files, or secret keys into your container image. Create .dockerignore in the project folder:

📁 File: investor_hunter/.dockerignore
env/
.env
__pycache__/
*.pyc

Step 4: Create the Dockerfile

Create a file named Dockerfile (no file extension) in your investor_hunter project folder:

📁 File: investor_hunter/Dockerfile
FROM python:3.11-slim

WORKDIR /app

# Install dependencies
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copy project files
COPY . .

# Cloud Run automatically sets the $PORT environment variable (defaults to 8080)
CMD adk web --port $PORT --host 0.0.0.0

Step 5: Create a Dedicated Service Account (Least Privilege)

For security best practices, run your cloud application with a dedicated Service Account rather than the default compute account.

Run these commands in your terminal:

# Set your project ID
export PROJECT_ID="YOUR_PROJECT_ID"

# 1. Create the dedicated service account
gcloud iam service-accounts create pitch-coach-sa \
  --display-name="Pitch Coach Service Account"

# 2. Grant Gemini Enterprise Agent Platform model invocation access
gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:pitch-coach-sa@$PROJECT_ID.iam.gserviceaccount.com" \
  --role="roles/aiplatform.user"

# 3. Grant Search / Data Store viewer access
gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:pitch-coach-sa@$PROJECT_ID.iam.gserviceaccount.com" \
  --role="roles/discoveryengine.viewer"

Step 6: Deploy to Cloud Run

From the folder where your Dockerfile is located, run the deployment command:

gcloud auth login
# if you are not inside the investor_hunter folder, change directory with cd command:
cd investor_hunter/
# from inside of the investor_hunter run:
gcloud run deploy pitch-coach-adk \
  --source . \
  --region europe-west4 \
  --allow-unauthenticated \
  --service-account pitch-coach-sa@$PROJECT_ID.iam.gserviceaccount.com \
  --set-env-vars GOOGLE_GENAI_USE_ENTERPRISE=True,GOOGLE_CLOUD_PROJECT="$PROJECT_ID",GOOGLE_CLOUD_LOCATION="global" \
  --max-instances=3

When/if prompted: - Confirm Y to proceed with the build and deployment. - Confirm Y to allow unauthenticated invocations (so your web app is accessible for this hands-on workshop).

Workshop Note: --allow-unauthenticated vs Production Ingress

For this workshop, we deploy with --allow-unauthenticated so you can immediately test your web interface from your browser. In production, enterprise applications restrict public access using Identity-Aware Proxy (IAP), Cloud Load Balancing, or IAM service-to-service authentication (see Level 6 below).

Final Test

  1. The deployment will take about 2–3 minutes.
  2. Once finished, the terminal outputs a Service URL (e.g., https://pitch-coach-adk-xyz.run.app). Open that link in your browser to test your live Multi-Agent Pitch Coach!

🌐 Mapping Custom Domains to Cloud Run (Regional Availability Note)

By default, Cloud Run assigns a generated *.run.app subdomain. When you are ready to point your startup's custom domain (e.g. coach.yourstartup.com):

  • Direct Domain Mapping (Beta): Cloud Run provides built-in direct domain mappings, but it is only available in selected regions (e.g., us-central1, us-east1, europe-west1, asia-east1) and is not supported in regions like europe-west4.
  • Global External HTTPS Load Balancer (Serverless NEG): For production apps in any region, map your custom domain through a Google Cloud Global External Application Load Balancer with a Serverless NEG. This provides global Google-managed SSL certificates, edge CDN caching, and Cloud Armor security.

🔒 Level 6: Production Security, Cost Governance & Architecture Guidance ⏱️ 10 mins

Building with AI in production requires solid financial and security guardrails. In this level, we review essential production architecture advice, cost controls, and security patterns (including Google Cloud Model Armor and Identity-Aware Proxy) so you know how to safely scale your agent from prototype to enterprise production:

1. Cost Protection & Spending Reality

Critical Billing Reality: Budget Alerts DO NOT Stop Spend!

A standard Google Cloud Budget Alert only sends an email notification when spending crosses a percentage threshold (e.g., 50%, 90%, 100%). It does NOT stop API requests or cap spending.

Furthermore, billing data and cost telemetry can be delayed by several hours up to 24–48 hours. If an agent gets caught in an unintended loop or faces a scraping surge, significant costs could accrue before an alert email arrives.

To properly protect your startup budget, use a defense-in-depth approach:

  • Cloud Run Instance Caps (--max-instances=3): Never deploy serverless containers with unbounded auto-scaling. Setting a strict upper bound (e.g., 3 instances) ensures your application cannot auto-scale into a massive compute bill during unexpected traffic spikes or automated bot crawls.
  • Hard Spend Caps (Google Cloud Preview): Google Cloud now offers project-level Spend Cap budgets. When estimated spend reaches your cap, Google Cloud automatically triggers a circuit breaker to pause eligible billable services and halt further charges until manually resumed. (Preview features are not intended for production use; spend caps are currently available for selected services, including GEAP and Cloud Run).
  • AI Cost Anomaly Detection: Google Cloud provides automated, ML-powered Cost Anomaly Detection tuned for GenAI workloads. It continuously models baseline usage and flags sudden, unexpected token or API request surges in near real-time without requiring manual threshold setup.
  • API Quota Overrides & Rate Limits: In the Google Cloud Console (IAM & Admin -> Quotas & System Limits), you can set custom Quota Overrides to reduce your maximum Requests Per Minute (RPM) or Tokens Per Minute (TPM) below default limits, preventing accidental high-volume consumption. In Google AI Studio, budget exposure is managed via Spend Caps and automatically applied tier limits rather than manual RPM dials.

2. Semantic Security with Model Armor

Traditional firewalls only inspect network packets (IPs, ports). GenAI applications need semantic inspection to protect against prompt-level attacks.

Google Cloud Model Armor acts as an AI firewall that sits in front of your LLMs and agents:

  • Prompt Injection & Jailbreak Defense: Detects and blocks adversarial instructions designed to bypass system prompts or hijack agent behavior.
  • PII & Data Leakage Prevention: Scans agent inputs and responses to prevent accidental disclosure of sensitive credentials, financial records, or personal data.
  • Harmful Content Filtering: Enforces enterprise safety standards across hate speech, harassment, and unsafe URLs.

To learn more:

3. Production Ingress & Access Control (Why Restrict Unauthenticated Access?)

In production, you should never leave AI agent endpoints open to unauthenticated public access (--no-allow-unauthenticated). Leaving an agent exposed invites bot scraping, prompt injection probes, and unauthorized compute/token drain.

Instead, secure your Cloud Run service using enterprise ingress patterns:

graph LR
    User["Client / Internal User"] --> LB["Cloud Load Balancer + Cloud Armor"]
    LB --> IAP["Identity-Aware Proxy (IAP)<br/>Google Workspace / MFA / SSO"]
    IAP --> Run["Cloud Run Agent<br/>Internal Ingress Enabled"]
  • Identity-Aware Proxy (IAP) & Cloud Load Balancing: Place your Cloud Run service behind an HTTPS Cloud Load Balancer with Identity-Aware Proxy (IAP). IAP enforces user authentication (Google Workspace, SSO, MFA, context-aware device policies) before requests can reach your agent container.
  • Internal Ingress Only: Configure Cloud Run ingress to --ingress=internal-and-cloud-load-balancing or --ingress=internal. This disables direct public access to the *.run.app URL, ensuring traffic only flows through your authenticated Load Balancer or VPC.
  • API Gateway & JWT Token Verification: For developer or mobile app APIs, front Cloud Run with Google Cloud API Gateway or Apigee to validate signed JWT/OAuth2 tokens and enforce per-client rate limits.
  • Service-to-Service IAM Authentication: For backend architectures, require callers to authenticate with Google IAM OIDC tokens (Authorization: Bearer $(gcloud auth print-identity-token)), ensuring only authorized microservices can invoke the agent.

4. Key Management & IAM Best Practices

  • Never commit .env or Service Account keys to Git. Use .dockerignore and .gitignore.
  • In Google AI Studio / Google Cloud Console, restrict API keys so they can only be used by specific APIs (e.g., restricting a key exclusively to the Gemini API) or specific IP addresses.
  • In Cloud Run, authenticate via IAM Service Accounts rather than exporting long-lived JSON keys.

🌟 Bonus Track 1: Interactive VC Sparring Partner (Debate Mode)

Instead of a one-shot evaluation, you can turn your agent into an interactive VC Sparring Partner (simulating a tough Y Combinator partner interview).

📁 File: investor_hunter/agent.py
from google.adk.agents import Agent
from google.adk.models.google_llm import Gemini
from google.genai import types

shared_model = Gemini(
    model="gemini-3.7-flash",
    retry_options=types.HttpRetryOptions(initial_delay=2, attempts=3)
)

root_agent = Agent(
    name="vc_sparring_partner",
    model=shared_model,
    instruction=(
        "You are a notoriously sharp, direct Venture Capital partner conducting a live pitch meeting.\n"
        "- DO NOT give all your feedback at once.\n"
        "- Ask EXACTLY ONE probing, critical question at a time.\n"
        "- Interrogate the founder on: CAC payback period, distribution advantages, moats against tech giants, and retention.\n"
        "- When the founder answers, challenge their assumptions with skepticism before asking the next question.\n"
        "- After 4-5 rounds of Q&A, deliver your final verdict: 'I'M IN (Term Sheet Offered)' or 'I'M PASSING', with a 2-sentence rationale."
    )
)

Test It

Update your agent.py with the code above and run adk web. Spar with your AI VC partner turn-by-turn:

  1. Turn 1 (Opening Pitch):

    • Prompt: "Hi, I'm pitching BarkBand AI. We build smart biometric dog collars that monitor pet vitals and translate bark acoustics. We are raising a $3.5M Seed round at a $35M valuation."
    • Expected behavior: The VC immediately challenges the \$35M valuation against your early-stage hardware risk with a single sharp question.

  2. Turn 2 (Defending Traction & Retention):

    • Prompt: "We already have 800 active beta collars generating $150k in ARR, and our monthly subscription churn is under 1.5%."
    • Expected behavior: The VC acknowledges the retention metric, but immediately drills into Customer Acquisition Cost (CAC) and customer payback period.

  3. Turn 3 (Go-To-Market & Burn Rate):

    • Prompt: "We plan to acquire customers by spending $400k of our initial $500k seed funding on celebrity TikTok influencers."
    • Expected behavior: The VC ruthlessly attacks the reckless CAC burn rate and asks how you plan to build an organic, defensible distribution moat.

  4. Turn 4 (Closing & Verdict):

    • Prompt: "We are also partnering directly with veterinary clinic networks for B2B2C wholesale distribution at zero CAC."
    • Expected behavior: After 4 rounds of interrogation, the VC delivers a definitive final verdict: either offering a term sheet (with valuation discount conditions) or passing with an investor rationale.

🌟 Bonus Track 2: Asynchronous Batch Due Diligence Pipeline (50% Cost Savings)

When evaluating dozens of startup applications (e.g. for an accelerator batch or hackathon), running real-time requests can be expensive and hit rate limits. The Gemini Batch API processes non-instant workloads asynchronously at 50% of the standard token cost.

1. Prepare batch_requests.jsonl

📁 File: investor_hunter/batch_requests.jsonl
{"key": "pitch_01", "request": {"contents": [{"parts": [{"text": "Critique this pitch: Smart cat water fountain with AI camera for urinary tract monitoring. $120 retail, $8/mo subscription."}]}]}}
{"key": "pitch_02", "request": {"contents": [{"parts": [{"text": "Critique this pitch: On-demand dog walker marketplace aiming to capture 40% of the European market with $200k seed funding."}]}]}}

2. Submit Batch Job via Python

📁 File: investor_hunter/run_batch.py
from google import genai

client = genai.Client()

# 1. Upload the requests file
uploaded_file = client.files.upload(file="batch_requests.jsonl")

# 2. Create the asynchronous batch job at 50% discount
batch_job = client.batches.create(
    model="gemini-3.5-flash-lite",
    src={"file_name": uploaded_file.name}
)

print(f"Batch job initiated: {batch_job.name}")
print(f"Status: {batch_job.state}")

Once completed, you can retrieve all evaluations in bulk without having consumed any real-time interactive quota.

🌟 Bonus Track 3: BigQuery Analytics via Model Context Protocol (MCP)

Real venture funds, accelerators, and startup studios maintain proprietary dealflow data, cohort metrics, and valuation multiples in data warehouses like Google BigQuery.

The Model Context Protocol (MCP) provides an open, standardized protocol for AI agents to connect to data sources, discover schemas, and run queries. In this track, you will connect your ADK agent directly to BigQuery using McpToolset.

💡 What is Google BigQuery? (The Enterprise AI Data Warehouse)

Google BigQuery is Google Cloud's fully managed, serverless enterprise data warehouse. It allows you to run blazing-fast SQL queries across terabytes to petabytes of structured tabular data with zero infrastructure setup or management.

Why connect AI Agents to BigQuery via MCP?

  • From Text to Empirical Data: While standard RAG (Level 2) searches unstructured text and PDF documents, BigQuery allows your agent to query live, structured relational data (deal benchmarks, CAC payback numbers, revenue cohort analytics, CRM records).
  • Model Context Protocol (MCP) Standard: Instead of writing custom SQL generation scripts, ADK uses the Model Context Protocol (mcp-server-bigquery) to let the agent safely discover table schemas, formulate SQL queries, execute them in the warehouse, and ground its pitch evaluations in real numbers.
  • Free Tier: BigQuery includes a generous monthly free tier (10 GB storage and 1 TB of SQL queries processed per month free).

Step 1: Create Dataset and Load Venture Benchmarks Data

You can populate realistic startup valuation benchmarks into BigQuery using Google Cloud Shell or your local terminal with bq:

# 1. Set your GCP Project ID
export PROJECT_ID="YOUR_PROJECT_ID"

# 2. Create the BigQuery dataset (e.g. in region europe-west4)
bq --location=europe-west4 mk -d $PROJECT_ID:venture_intelligence

# 3. Create the table and load benchmark records
bq query --use_legacy_sql=false \
"CREATE OR REPLACE TABLE \`${PROJECT_ID}.venture_intelligence.deal_benchmarks\` (
  industry STRING OPTIONS(description='Startup industry vertical'),
  stage STRING OPTIONS(description='Financing stage: Seed, Series A'),
  median_arr_multiple FLOAT64 OPTIONS(description='Median ARR valuation multiple'),
  median_cac_payback_months INT64 OPTIONS(description='Median CAC payback in months'),
  median_burn_multiple FLOAT64 OPTIONS(description='Median Net Burn / Net New ARR ratio'),
  median_seed_round_usd INT64 OPTIONS(description='Median round size in USD'),
  median_pre_money_valuation_usd INT64 OPTIONS(description='Median pre-money valuation in USD')
);

INSERT INTO \`${PROJECT_ID}.venture_intelligence.deal_benchmarks\`
VALUES
  ('B2B SaaS', 'Seed', 12.5, 12, 1.2, 3000000, 15000000),
  ('B2B SaaS', 'Series A', 10.2, 14, 1.4, 9000000, 45000000),
  ('AI / ML Infrastructure', 'Seed', 22.0, 9, 1.1, 5000000, 28000000),
  ('AI / ML Infrastructure', 'Series A', 18.5, 12, 1.3, 15000000, 85000000),
  ('Fintech', 'Seed', 9.0, 15, 1.5, 3500000, 18000000),
  ('Fintech', 'Series A', 7.8, 18, 1.7, 10000000, 55000000),
  ('Healthtech / MedTech', 'Seed', 14.0, 18, 1.8, 2500000, 14000000),
  ('Consumer DTC', 'Seed', 2.8, 8, 2.1, 1500000, 8000000),
  ('DevTools & Cloud Security', 'Seed', 18.0, 10, 1.1, 4000000, 22000000),
  ('DevTools & Cloud Security', 'Series A', 14.5, 13, 1.3, 12000000, 65000000);"

Step 2: Connect BigQuery MCP Server to ADK

Make sure the MCP package is installed in your virtual environment:

pip install "mcp==1.26.0"

Configure the McpToolset using standard BigQuery MCP server parameters:

📁 File: investor_hunter/agent.py
import os
from google.adk.agents import Agent
from google.adk.tools import McpToolset
from google.adk.tools.mcp_tool.mcp_toolset import StdioConnectionParams, StdioServerParameters
from google.adk.models.google_llm import Gemini

PROJECT_ID = os.environ.get("GOOGLE_CLOUD_PROJECT", "YOUR_PROJECT_ID")
# BigQuery datasets are regional (e.g. europe-west4, US, EU) and do not use Vertex AI's "global" location
BQ_LOCATION = os.environ.get("BIGQUERY_LOCATION", "europe-west4")

# 1. Connect ADK to BigQuery via the BigQuery MCP Server
bigquery_mcp = McpToolset(
    connection_params=StdioConnectionParams(
        server_params=StdioServerParameters(
            command="uvx",
            args=[
                "--with", "mcp==1.26.0",
                "mcp-server-bigquery",
                "--project", PROJECT_ID,
                "--location", BQ_LOCATION
            ]
        )
    )
)

# 2. Equip your Quantitative Analyst Agent with BigQuery MCP Tools
root_agent = Agent(
    name="venture_benchmarks_analyst",
    model=Gemini(model="gemini-3.7-flash"),
    instruction=(
        "You are a quantitative venture capital analyst with access to proprietary "
        "startup deal benchmarks in BigQuery (table: `venture_intelligence.deal_benchmarks`).\n"
        "When evaluating a founder's pitch, query BigQuery to compare their claims against "
        "industry median ARR multiples, CAC payback periods, and seed round valuations."
    ),
    tools=[bigquery_mcp]
)

Step 3: Test It

Ask the agent to benchmark a pitch against your BigQuery dataset:

  • "I am raising a $5M Seed round at a $35M pre-money valuation for an AI Infrastructure startup with 9-month CAC payback. How does this compare to actual industry benchmarks in BigQuery?"

The agent will autonomously discover the table schema, construct the SQL query, execute it in BigQuery via MCP, and return an empirical comparison (e.g. noting that the median AI Seed valuation is \$28M, so their ask is in the top quartile).

🌟 Bonus Track 4: Automated Model Evaluation & "LLM-as-a-Judge" Benchmarking

When building AI products, founders face a constant trade-off: Speed & Cost vs. Reasoning Depth. How do you decide whether to power your agent with gemini-3.5-flash-lite, gemini-3.7-flash, or gemini-3.1-pro-preview?

In Gemini Enterprise Agent Platform (GEAP) and ADK, you can run Automated Evaluation Pipelines where an evaluator model (or the GEAP Evaluation Service) scores candidate models using LLM-as-a-Judge.

graph LR
    Pitch["Test Pitch Input"] --> M1["gemini-3.5-flash-lite<br/>Ultra Fast & Cost-Efficient"]
    Pitch --> M2["gemini-3.7-flash<br/>Balanced Speed & Reasoning"]
    Pitch --> M3["gemini-3.1-pro-preview<br/>Deep Multi-Step Reasoning"]

    M1 --> Judge["LLM-as-a-Judge Evaluator<br/>Strict Pydantic Rubric"]
    M2 --> Judge
    M3 --> Judge

    Judge --> Board["Model Benchmark Leaderboard<br/>• Latency in seconds<br/>• Rigor Score: 1 to 5<br/>• Groundedness Score: 1 to 5<br/>• Actionability Score: 1 to 5"]

The Model Shootout Script (evaluate_models.py)

Create a script to run your test pitches across all three models and evaluate their responses with a judge:

📁 File: investor_hunter/evaluate_models.py
import asyncio
import os
import time
import warnings
import logging
from dotenv import load_dotenv
from pydantic import BaseModel, Field
from google import genai
from google.genai import types
from google.adk.agents import Agent
from google.adk.models.google_llm import Gemini
from google.adk.runners import Runner
from google.adk.sessions import InMemorySessionService

# Suppress SDK deprecation / advisory notices for a clean terminal output
warnings.simplefilter("ignore")
os.environ["PYTHONWARNINGS"] = "ignore"
for log_name in ["google", "google.genai", "google_adk", "google.adk"]:
    logging.getLogger(log_name).setLevel(logging.ERROR)

# Automatically load API keys & environment variables from .env
load_dotenv()

# 1. Define the LLM-as-a-Judge Evaluation Scorecard Schema
class JudgeScorecard(BaseModel):
    critique_rigor: int = Field(ge=1, le=5, description="1-5 score on how effectively it challenged burn rate and moats")
    factual_accuracy: int = Field(ge=1, le=5, description="1-5 score on realism vs hallucinations")
    actionability: int = Field(ge=1, le=5, description="1-5 score on concrete, useful advice for founders")
    key_strengths: str = Field(description="1-2 sentences highlighting what the critique did well")
    key_weaknesses: str = Field(description="1-2 sentences highlighting missed points or superficial analysis")
    rationale: str = Field(description="Overall 2-sentence summary of the score")

# 2. Candidate Models to Benchmark in ADK
CANDIDATE_MODELS = [
    "gemini-3.5-flash-lite",
    "gemini-3.7-flash",
    "gemini-3.1-pro-preview"
]

TEST_PITCH = """
Startup: BarkBand AI
Product: Smart dog collar with AI bark translator and GPS.
Funding Ask: $3.5M Seed round at a $35M Pre-Money valuation on $150k ARR.
GTM Plan: Spending $400k of our $500k cash on TikTok influencers in Month 1.
"""

async def run_adk_model_shootout():
    judge_client = genai.Client()
    session_service = InMemorySessionService()
    results = []

    print("\n🔍 Running ADK Model Shootout & LLM-as-a-Judge Benchmark...\n")

    for model_name in CANDIDATE_MODELS:
        print(f"  ⚡ Evaluating agent powered by: {model_name}...")

        # A. Build the ADK Agent powered by the candidate model
        coach_agent = Agent(
            name=f"pitch_coach_{model_name.replace('.', '_').replace('-', '_')}",
            model=Gemini(
                model=model_name,
                retry_options=types.HttpRetryOptions(initial_delay=2, attempts=3)
            ),
            instruction="You are a notoriously sharp, direct VC pitch coach. Critique the founder's pitch ruthlessly."
        )

        runner = Runner(
            app_name="pitch_benchmark",
            agent=coach_agent,
            session_service=session_service,
            auto_create_session=True
        )

        # B. Run the ADK Agent and measure latency
        start_time = time.time()
        critique_text = ""
        user_message = types.Content(role="user", parts=[types.Part(text=TEST_PITCH)])

        async for event in runner.run_async(
            user_id="founder_eval",
            session_id=f"session_{model_name}",
            new_message=user_message
        ):
            if event.content and event.content.parts:
                for part in event.content.parts:
                    if part.text:
                        critique_text += part.text

        latency = round(time.time() - start_time, 2)

        # C. Evaluate ADK Agent output with LLM-as-a-Judge
        judge_prompt = f"""
        You are an expert AI evaluator. Grade the following ADK agent pitch critique according to our startup rubric:

        [PITCH]: {TEST_PITCH}
        [AGENT CRITIQUE]: {critique_text}
        """

        judge_eval = judge_client.models.generate_content(
            model="gemini-3.7-flash",
            contents=judge_prompt,
            config=types.GenerateContentConfig(
                response_mime_type="application/json",
                response_schema=JudgeScorecard
            )
        )

        scorecard = JudgeScorecard.model_validate_json(judge_eval.text)
        results.append({
            "model": model_name,
            "latency": latency,
            "rigor": scorecard.critique_rigor,
            "accuracy": scorecard.factual_accuracy,
            "actionability": scorecard.actionability,
            "strengths": scorecard.key_strengths,
            "weaknesses": scorecard.key_weaknesses,
            "rationale": scorecard.rationale
        })

    # Print Clean Formatted Leaderboard
    print("\n" + "=" * 78)
    print(f"{'ADK Model':<26} | {'Latency (s)':<12} | {'Rigor':<6} | {'Accuracy':<9} | {'Actionability':<13}")
    print("-" * 78)
    for r in results:
        print(f"{r['model']:<26} | {r['latency']:<12.2f} | {r['rigor']:<6} | {r['accuracy']:<9} | {r['actionability']:<13}")
    print("=" * 78)

    # Print Detailed Qualitative Rationale
    print("\n📝 Detailed Judge Evaluation & Rationale:\n")
    for r in results:
        print(f"🔹 {r['model']}:")
        print(f"   • Strengths:  {r['strengths']}")
        print(f"   • Weaknesses: {r['weaknesses']}")
        print(f"   • Verdict:    {r['rationale']}\n")

if __name__ == "__main__":
    asyncio.run(run_adk_model_shootout())

📊 Founder Decision Matrix

Model Tier Primary Strength Recommended Startup Use Case Relative Cost Typical Latency
gemini-3.5-flash-lite Ultra-low latency, high throughput Intent classification, sub-agent tool routing, high-volume batch triage Lowest ($) < 0.5s
gemini-3.7-flash Balanced reasoning & low latency Interactive pitch coaching, tool calling, live conversational agents Moderate ($$) 1–2s
gemini-3.1-pro-preview Deep multi-step reasoning & complex math Comprehensive due diligence memos, deep financial audits, LLM-as-a-Judge auto-rater Premium ($$$) 3–5s

🤖 Native ADK Evaluation CLI (adk eval)

In addition to programmatic benchmarking in Python, ADK provides a built-in evaluation command line tool (adk eval) designed for automated regression testing in CI/CD:

adk eval investor_hunter --eval_set_file=eval_sets/pitches.evalset.json

Under the hood, ADK's AgentEvaluator executes the full agent workflow and grades:

  • tool_trajectory_avg_score: Validates whether the agent selected the appropriate tools (e.g., Yahoo Finance, BigQuery MCP) with valid arguments.
  • final_response_match_v2: Measures how accurately the response satisfies your rubric criteria without regressions.
  • safety_v1 & hallucinations_v1: Integrates with the GEAP Gen AI Evaluation Service to flag ungrounded assertions and safety violations.

Support & Resources

Congratulations! You have built a sophisticated Multi-Agent system using the Google Agent Development Kit and deployed it to the Cloud. You are now equipped to build production-grade AI tools for your startup.

If you were using your own Google Cloud project during this workshop, make sure you clean up or delete unused resources to avoid incurring unnecessary costs.

💬 Feedback & Issue Reporting

Found a bug, hit an unexpected quota or dependency hurdle, or have feedback on the material? We'd love to hear from you!

📚 Official Documentation

🤝 Need more help?

Worklog

  • The instructions were first used during Founder Story event in Warsaw, March 2026
  • Last update: 08.2026 (including: ADK 2.x, new Gemini models, additional tasks, product name update - Vertex AI -> Gemini Enterprise Agent Platform)