DEV Community: Google AI

Behind the scenes: How we build, test, and scale Google Agent Skills

Remigiusz Samborski — Mon, 03 Aug 2026 14:33:20 +0000

AI agents are only as good as the instructions and context you give them. When we launched Google Agent Skills, our goal was simple: encode Google Cloud domain knowledge into structured, open-source instructions that make AI coding agents significantly smarter, safer, and more accurate.

Today, I want to take you behind the scenes of Google Agent Skills. As a team member working directly on these skills, I will share how we started, how we maintain quality at scale, and how we handle governance for public and internal skills.

How it started: The Next'26 kickoff swarm

The Google Agent Skills project didn't start in a vacuum. It kicked off as a fast-paced "swarm" effort leading up to Google Cloud Next 2026.

A cross-functional task force led by Developer Advocates and Technical Writers came together with a clear goal: package Google Cloud domain knowledge into structured, agent-readable instructions.

The launch was announced in the official Google Agent Skills launch post. The initial community reception exceeded our expectations with over 15,000 GitHub stars!

Once developers and engineering teams inside and outside Google saw how effectively skills guided AI agents (reducing hallucinations and enforcing best practices), many wanted in. Soon, a wave of product teams wanted to contribute skills for their own Google services (not limited to Cloud, i.e. Ads).

The challenge: Scaling without losing quality

Popularity brings a major challenge: quality control.

When different teams contribute skills, keeping a consistent standard becomes tough. A poorly written skill with vague instructions, broken links, or missing edge cases degrades the entire agent experience.

To enable teams to publish skills while protecting the developer experience, we had to set a very high bar.

This meant the process was critical. Without clear standards and automated governance, an open-source skills repository quickly becomes chaotic.

So let's dive into details of how we maintain quality as we scale.

The anatomy of an Agent Skill

To keep skills consistent across many Google services, every skill follows a standardized repository layout:

{skill-name}/
├── SKILL.md                 # Required: Main instructions & frontmatter metadata
├── OWNERS                   # Required: Skill maintainers (kept internal)
├── EVAL.yaml                # Required: Evaluation prompt suites & rubrics (kept internal)
├── reference/               # Optional: In-depth technical docs & schemas
├── scripts/                 # Optional: Executable helper scripts
├── assets/                  # Optional: Static resources & diagrams
└── _internal/               # Optional: Test mocks & internal data (kept internal)

Architectural best practice: Prefer remote MCP tools

When designing skills, our guiding principle is: Reference remote Model Context Protocol (MCP) tools whenever possible, falling back to CLI or API calls only when necessary. Remote MCP servers are best suited for Agentic workloads by providing tools, while also offering built-in auth and IAM governance.

Public export

We build and evaluate our skills internally first to make sure they work and are properly validated. Once ready to go public, we use automated export rules to publish to GitHub. This keeps public repos clean while stripping out internal assets, ownership information, and evaluation suites.

Automated checks on check-in

Before any skill enters the repository, it must pass an automated CI/CD pipeline:

Linters: We validate frontmatter metadata, line counts, directory layout, and strict naming conventions.
Link Checkers: We test every URL using link-checking tools to eliminate 404s and hallucinated links before merge. Hint: if you're building a similar solution I recommend trying out lychee.
AI-Assisted Checklists: We use automated validation checks to verify that instructions follow required structural patterns and guardrails.

Example GitHub Action for skill linting

While our development relies on Google's internal tooling, public open-source skill repositories can use standard GitHub Actions for CI/CD.

If you are maintaining your own skill library on GitHub, linting is part of a larger check suite to keep a high quality bar. The following GitHub Action configuration demonstrates how to automatically run skill validation in your repository using skills-ref:

name: 'Validate Skills'

on:
  push:
    branches: ['main']
  pull_request:
    branches: ['main']
  workflow_dispatch:

defaults:
  run:
    shell: 'bash'

jobs:
  validate:
    runs-on: 'ubuntu-latest'
    permissions:
      contents: 'read'
    steps:
      - name: 'Checkout repository'
        uses: 'actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5' # ratchet:actions/checkout@v4

      - name: 'Set up Python'
        uses: 'actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065' # ratchet:actions/setup-python@v5
        with:
          python-version: '3.12'

      - name: 'Install skills-ref'
        run: |
          python3 -m pip install skills-ref
          echo "$HOME/.local/bin" >> $GITHUB_PATH

      - name: 'Validate skills'
        run: |
          shopt -s nullglob
          for skill_dir in skills/*/; do
            echo "Validating skill: $skill_dir"
            agentskills validate "$skill_dir"
          done

Continuous evals (on submit & weekly)

Documentation and APIs evolve, and so do LLM models and agent harnesses. A skill that works today might break tomorrow if an underlying API, model, or agent harness changes.

To set an initial quality bar and prevent degradation, we run continuous evaluations:

On-submit evaluations: Authors must provide explicit evaluation prompt suites and scoring rubrics. Every new skill that we launch is first evaluated internally to ensure its accuracy and efficiency.
Weekly quality checks: We run continuous, scheduled evaluation jobs against the full skill library to catch regressions early.

Skill authors must supply multiple evaluation test cases, each containing a prompt and a set of expectations. With each evaluation suite, we compare the performance of agents with and without each skill.

And look at two main dimensions:

Accuracy - response quality and task completion rate
Efficiency - number of consumed tokens and time for completion

Moreover we run our evals multiple times against different agent frameworks to obtain statistically significant results.

Finally the 2x2 matrix proves whether a skill delivers a measurable accuracy and efficiency uplift.

Skills are products, not snippets

A key lesson learned from our work is that a skill is a living product, not a one-off document.

To ensure long-term reliability, we established strict ownership rules:

Repo maintainers oversee repository health, CI pipelines, and architectural standards.
Skill owners are responsible for maintaining their skills long-term. For example, if a product API changes, the skill owner updates the skill. The same applies to quality degradation found during evaluation runs.

Supporting authors: Tools and agentic workflows

Writing effective instructions and evaluation suites requires practice and we don't expect skill authors to craft everything from scratch.

To support our contributors, we built several tools and agentic workflows:

Internal skills designed specifically to assist authors building new skills and writing robust evaluations.
Agentic tools built with the ADK that run multi-agent loops for authoring and self-critique, with an easy export path to the main repository.

I will dive deeper into these authoring tools and agentic workflows in future articles.

Internal efficiency with "DevRel Skills"

While Google Agent Skills hosts public skills for external developers, we also launched a parallel internal initiative called DevRel Skills.

DevRel Skills focus on building agent skills specifically for internal team workflows. By encoding internal processes — such as content transformation, SEO optimization, internal reporting, etc. - into dedicated skills, we help our team work more effectively and consistently every day.

Wrap-up and over to you

Building quality agent skills at scale requires combining clear standards, rigorous evaluation, automated CI/CD, and long-term ownership.

As agentic development grows, we'd love to hear from you:

How are you building and testing agent skills in your workflow?
What checks or evals do you use to verify agent responses?

Let us know in the comments or reach out on socials!

Links and further reading

To get started with Google Agent Skills, check out:

Google Agent Skills Repo: github.com/google/skills
Part 1: Introduction: What Are Google Cloud Agent Skills?
Part 2: Practical Guide: Intermediate Agent Skills in Action

What's next?

If you found this post helpful:

Add reactions to this post by pressing the heart ❤️ button.
Share this post with your friends on socials.
Connect with me via LinkedIn, X or Bluesky.

Thanks for reading!

Skills vs MCP: How AI tools have evolved

Tilde A. Thurium — Thu, 30 Jul 2026 17:50:23 +0000

Eighteen months ago, MCP was the thing. Every demo and chatbot connector was running on MCP under the hood. When I started seeing everyone talk about Skills, I got curious. How are MCP and Skills connected? Are they different lenses on the same problem?

I brought these questions to @greggyb again in our latest video.

What's in the video

What MCP actually does: giving a model programmatic access to APIs and the file system through natural language
Downsides of MCP: context bloat from loading hundreds of lines of tool definitions for tools you're not even using
What a Skill actually is (spoiler: pretty much a markdown file containing a reusable prompt)
Progressive disclosure: why an agent can "know about" 20 skills without loading the full instructions for all of them
Why MCP and Skills aren't competitors, and how Skills can even teach your agent how to use MCP tools

My favorite line from this one: the hottest programming language right now is English. Skills let non-developers write, iterate on, and share instructions that make an entire team's agents faster, no code required.

Are you using Skills yet? Curious where everyone's at.

7 Times Faster and Cheaper? Gemini 3.5 Flash Lite and Gemini 3.6 Flash in Google Cloud Databases

Gleb Otochkin — Sun, 26 Jul 2026 06:11:17 +0000

Only a couple of months ago, I wrote a blog post describing how to enable the latest (at the time) Gemini 3.5 Flash in Google Cloud databases. Now, it is time to introduce the newest model: Gemini 3.6 Flash. This model is fresher, with a knowledge cutoff date around the end of March this year, and it costs less. Let’s look at how it performs at first glance. I am particularly curious about its response times and how it compares to the previous model.

Cloud SQL

For Cloud SQL for Postgres, don’t forget to enable full AI integration via the google_ml extension to call modelsdirectly from a SQL query. If you are reading this AI integration overview right after the model announcement, you might need to register the model first. It wasn’t available by default when I tested it.

Here is the SQL statement to register the model. Don’t forget to replace the PROJECT_ID placeholder in the code with your actual Google Cloud project ID:

CALL google_ml.create_model(
    model_id => 'gemini-3.6-flash',
    model_request_url => 'https://aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/global/publishers/google/models/gemini-3.6-flash:generateContent',
    model_provider => 'google',
    model_type => 'generic',
    model_auth_type => 'cloudsql_service_agent_iam'
);

After that, your model is ready to be used:

SELECT google_ml.predict_row(
    model_id => 'gemini-3.6-flash',
    request_body => json_build_object(
        'contents', json_build_array(
            json_build_object(
                'role', 'user',
                'parts', json_build_array(
                    json_build_object('text', 'Explain MCP server for a relational database in 50 words or less.')
                )
            )
        )
    )
) ->'candidates' -> 0 -> 'content' -> 'parts' -> 0 -> 'text' AS ai_response;

To measure the latency, I’ve asked Google Antigravity to prepare a PL/pgSQL function to run that query a certain number of times and aggregate the results. It did a decent job, I needed only a few polishing and adjustments to make it working. Here are my benchmarking results for Gemini 3.6 Flash and Gemini 3.5 Flash:

quickstart_db=> SELECT * FROM benchmark_model_predictions('gemini-3.6-flash', 10);
 total_runs | avg_latency_ms | median_latency_ms | min_latency_ms | max_latency_ms 
------------+----------------+-------------------+----------------+----------------
         10 | 3694.53 | 3725.52 | 3313.01 | 4213.40
(1 row)

Time: 36947.554 ms (00:36.948)
quickstart_db=> SELECT * FROM benchmark_model_predictions('gemini-3.5-flash', 10);
 total_runs | avg_latency_ms | median_latency_ms | min_latency_ms | max_latency_ms 
------------+----------------+-------------------+----------------+----------------
         10 | 4918.86 | 5136.67 | 3936.69 | 5722.01
(1 row)

Time: 49190.861 ms (00:49.191)

It looks like, all other conditions being equal, Gemini 3.6 Flash was slightly faster than the previous model. Of course, this is a very crude measurement, and your results may vary. Since we are using a global endpoint, the routing might theoretically hit different regional endpoints. Furthermore, public model endpoints are shared services.

Next, I created a function to evaluate the quality of the responses and ran it for both models. The function uses the same query, receives the response, and sends the result to a more advanced model for evaluation. In this case, I used gemini-3.1-pro-preview as the judge:

quickstart_db=> SELECT * FROM benchmark_model_quality('gemini-3.6-flash', 'gemini-3.1-pro-preview', 5);
 total_runs | avg_quality_score | median_quality_score | min_quality_score | max_quality_score 
------------+-------------------+----------------------+-------------------+-------------------
          5 | 10.00 | 10.00 | 10 | 10
(1 row)

quickstart_db=> SELECT * FROM benchmark_model_quality('gemini-3.5-flash', 'gemini-3.1-pro-preview', 5);
 total_runs | avg_quality_score | median_quality_score | min_quality_score | max_quality_score 
------------+-------------------+----------------------+-------------------+-------------------
          5 | 9.80 | 10.00 | 9 | 10
(1 row)

quickstart_db=>

Both models delivered excellent results, but Gemini 3.6 Flash provided slightly better responses than its predecessor — at least according to the gemini-3.1-pro-preview judge.

What about AlloyDB? Let’s run the same performance benchmark on AlloyDB to see if the response times match our Cloud SQL results.

AlloyDB

Registering the new model in AlloyDB follows almost the same process, with the only difference being the ‘model_type’ parameter. In AlloyDB, we register it with the model type ‘llm’. Again, don’t forget to replace the PROJECT_ID placeholder with your actual project:

CALL google_ml.create_model(
model_id => 'gemini-3.6-flash',
model_request_url => 'https://aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/global/publishers/google/models/gemini-3.6-flash:generateContent',
model_provider => 'google',
model_type => 'llm'
);

For these tests, I used the exact same query and function as we did for Cloud SQL. AlloyDB is fully compatible with PostgreSQL and shares the same AI integration extension.

quickstart_db=> SELECT * FROM benchmark_model_predictions('gemini-3.5-flash', 10);
 total_runs | avg_latency_ms | median_latency_ms | min_latency_ms | max_latency_ms
------------+----------------+-------------------+----------------+----------------
         10 | 4899.00 | 4910.05 | 3631.22 | 5798.40
(1 row)

Time: 48992.149 ms (00:48.992)
quickstart_db=> SELECT * FROM benchmark_model_predictions('gemini-3.6-flash', 10);
 total_runs | avg_latency_ms | median_latency_ms | min_latency_ms | max_latency_ms
------------+----------------+-------------------+----------------+----------------
         10 | 4364.76 | 4368.65 | 3664.24 | 5008.42
(1 row)

Time: 43649.384 ms (00:43.649)
quickstart_db=>

This time, the results were much closer, and the response times were almost identical. It is hard to draw definitive conclusions here, considering we are using a shared service with global routing; there is no guarantee that consecutive requests are hitting the same physical endpoint. However, it appears that performance and response times are roughly equivalent for both models. Naturally, the quality of the responses remained consistent with our previous test, as quality depends directly on the models themselves.

Gemini 3.5 Flash Lite

But do you always need a “Pro” or “Flash” model for your queries? In many cases, you can get highly acceptable results from a “Lite” model like the newly released gemini-3.5-flash-lite. I tested its performance using the same benchmarking approach:

quickstart_db=> SELECT * FROM benchmark_model_predictions('gemini-3.5-flash-lite', 10);
 total_runs | avg_latency_ms | median_latency_ms | min_latency_ms | max_latency_ms
------------+----------------+-------------------+----------------+----------------
         10 | 827.08 | 882.05 | 499.95 | 1034.92
(1 row)

Time: 8272.929 ms (00:08.273)

It was about seven times faster than Gemini 3.6 Flash. But what about response quality?

quickstart_db=> SELECT * FROM benchmark_model_quality('gemini-3.5-flash-lite', 'gemini-3.1-pro-preview', 5);
 total_runs | avg_quality_score | median_quality_score | min_quality_score | max_quality_score
------------+-------------------+----------------------+-------------------+-------------------
          5 | 10.00 | 10.00 | 10 | 10
(1 row)

Time: 42923.480 ms (00:42.923)
quickstart_db=> SELECT * FROM benchmark_model_quality('gemini-3.5-flash-lite', 'gemini-3.1-pro-preview', 5);
 total_runs | avg_quality_score | median_quality_score | min_quality_score | max_quality_score
------------+-------------------+----------------------+-------------------+-------------------
          5 | 9.60 | 10.00 | 8 | 10
(1 row)

Time: 51722.997 ms (00:51.723)
quickstart_db=> SELECT * FROM benchmark_model_quality('gemini-3.5-flash-lite', 'gemini-3.1-pro-preview', 5);
 total_runs | avg_quality_score | median_quality_score | min_quality_score | max_quality_score
------------+-------------------+----------------------+-------------------+-------------------
          5 | 9.80 | 10.00 | 9 | 10
(1 row)

Time: 53252.325 ms (00:53.252)

I ran the same benchmark three times, and even the worst-performing run was highly scored. The average scores ranged from 9.6 to 10 (with 10 being a perfect score). I was impressed by both the quality and the speed.

Summary

The new Gemini 3.6 Flash model is less expensive than Gemini 3.5 Flash. Considering it offers comparable or better quality and the same or faster response times, it is definitely a win.

However, Gemini 3.5 Flash Lite is maybe even more impressive, delivering excellent quality while running seven times faster at a very attractive price. This means that many simpler, everyday tasks can be delegated to the Lite model to keep costs down, reserving more advanced models for complex problems that require deep reasoning and multi-step iterations.

AI builder essentials: tokens, context windows and RAG 101

Tilde A. Thurium — Fri, 24 Jul 2026 19:16:22 +0000

Tokens are an important foundational concept that underlie how we interact with LLMs. @greggyb and myself recorded a quick video to demystify what a token actually is and unpack several other related concepts.

What's in the video

What is a token? Tokens are the basic unit of input and output that LLMs operate on.
What is retrieval-augmented generation (AKA RAG)? Providing a model with extra data that isn't already in the model's training dataset, and is relevant to a specific query.
What are context windows? Context windows are how many tokens a model can use for input and output. Context window size varies from model to model, but it has increased a lot in recent years.
What is tokenmaxxing? Does using more tokens really mean you're being more productive? (Spoiler alert: no.)

To paint a bigger picture: more context you give a large language model, the better your responses are likely to be. The design patterns for providing that context have evolved at a rapid pace, and are likely to continue doing so.

What AI terms should we demystify next? Let us know!

Claude Opus 5 is Live on Agent Platform 🚀

Jen Harvey — Fri, 24 Jul 2026 17:37:35 +0000

Claude 5 Opus is officially available in the Model Garden on Agent Platform!

Built for highly complex, long-running agentic workflows, Claude 5 Opus brings advanced capabilities in coding, vision, and deep reasoning - allowing businesses to deploy next-generation AI agents with minimal oversight.

Using Claude 5 Opus on Agent Platform keeps your data inside your private Google Cloud network, controls access with IAM, and ensures your data is never used for model training. Built with high-security enterprise environments in mind, it is alsoZero Data Retention (ZDR) compatible.

Find it in the Agent Platform Model Garden 🌱

Investing in multi-agent AI safety research

Gemini Team — Fri, 24 Jul 2026 14:35:41 +0000

Scaling AI Safety Research for a Multi-Agent World

For the past decade, we've focused on making individual AI models more capable, helpful and safe. Now, Google DeepMind — together with Schmidt Sciences, the Cooperative AI Foundation, the Advanced Research and Invention Agency, and supported by Google.org — has announced a new technical research funding call of up to $10M for researchers worldwide.

As AI technology scales, we're entering a new era. Soon, millions of AI agents — built by different organizations — will interact across digital environments, communicating, negotiating and transacting with one another.

When these systems interact, they must do so safely and predictably. This shift creates a vital opportunity: we can strengthen the safety and stability of the entire AI ecosystem from the very beginning.

The funding call focuses on the study of how large-scale multi-agent AI systems behave as a group, and how we can provide frameworks to understand and mitigate against potential risks. By empowering researchers globally, we aim to solve the "invisible" safety risks that arise when independent systems interact across different networks.

Why the agent ecosystem matters

When large groups of AI agents interact, new collective behaviors and capabilities can emerge suddenly. Currently, we lack the tools to predict, measure and monitor these transitions. Most safety evaluations analyze models in isolation. However, as we and others have previously argued, interacting autonomous agents can produce complex, "emergent" behaviors that are difficult to anticipate.

Because this is a new area of research, it is critical to understand how these shifts occur. For example, could they cause an unpredictable flurry of economic activity or lead to new security challenges? Understanding how to manage these system-wide behaviors is our core objective.

Scaling the frontier of multi-agent safety research

Although foundational frameworks for multi-agent safety exist, the rapid evolution of these systems requires an immediate, large-scale expansion of research.

Our 2025 research established a framework for understanding these interactions, while our recent work on AI Agent Traps explores vulnerabilities agents face in adversarial environments. Now, we must move faster. We are at a critical juncture where the complexity of multi-agent interactions is outpacing existing safety models.

This funding call aims to accelerate progress by supporting a global network of independent researchers. A diverse community is essential to ensure safety standards are transparent and robust for everyone.

This effort also advances the mission of Schmidt Sciences' Science of Trustworthy AI and AI Agents programs, which support foundational work on understanding and mitigating risks from frontier AI systems, as well as ARIA's Scaling Trust programme, which seeks to unlock new forms of cyber-physical multi-agent coordination.

A collaborative call to action

No single lab can solve multi-agent safety alone. We invite academic and independent researchers to submit proposals in four priority areas:

Sandboxes and testbeds: Building realistic, reproducible environments to evaluate, compare and accelerate progress across all areas of multi-agent safety. This includes virtual marketplaces, simulated ecosystems and multi-organisation workflows.
The science of agent networks: Understanding the safety-relevant properties of interacting agent populations, including investigating how collective capabilities emerge and scale, how networks fail or become volatile and how to detect dangerous, unexpected population-level properties.
Strengthening agent infrastructure: Stress-testing the protocols for identity, reputation and commitment that are secure cross-platform agent interactions.
Oversight and control: Developing methods to monitor deployed agent populations and mitigate collective harms at scale.

How to participate

We invite researchers to review our call for proposals and join us in building a safe foundation for a multi-agent future.

The deadline to apply is August 8, 2026, with awardees expected to be announced in Autumn 2026.

For more details on technical requirements and the application process, visit our application portal.

Google Cloud Skills Tutorial — Part 2 : Intermediate Skills in Action

Romin Irani — Fri, 24 Jul 2026 00:57:29 +0000

Welcome to the definitive guide on Google Cloud Agent Skills.

The Series:

- Part 1 : What are Google Cloud Skills

- Part 2 : Intermediate Skills in Action (BigQuery and Cloud Run) (this blog)

_- Part 3 : Advanced Ops (WAF Security, Architecture, Custom Skills)

Part 4 : More Use Cases_

Before your agent or code can interact with any Google Cloud service, it needs permission to do so. Authentication is the very first step in the Google Cloud Agent Skills workflow because without it, every subsequent operation will fail with a 401 Unauthorized or 403 Forbidden error.

Setting up authentication correctly ensures a smooth, secure experience whether you are building locally, deploying to the cloud, or using agents.

Prerequisites: Manual Setup

While our agent will do most of the heavy lifting, authentication requires an initial manual login to establish your identity on your machine.

Run the following commands in your terminal:

# Set your active project
gcloud config set project YOUR_PROJECT_ID

# Login to the gcloud CLI
gcloud auth login

# Set up Application Default Credentials (ADC)
gcloud auth application-default login

Once this is done, you are ready to use the agent for everything else!

Confirming Skill Installation

For this step, we will use the google-cloud-recipe-auth skill. Confirm it's installed:

npx skills list

Prompt-Driven Authentication Checks

Instead of manually running diagnostic scripts or consulting complex decision trees, you can just ask your agent. The agent uses the google-cloud-recipe-auth skill to evaluate your environment and provide tailored guidance.

The responses given below are from running them in Antigravity CLI.

1. Verifying Authentication

You prompt: Check if my Google Cloud authentication is set up correctly for project YOUR_PROJECT_ID

Agent response:

Yes, your Google Cloud authentication is set up correctly for project PROJECT_ID.                                                       

  ### Verification Details:                                                                                                                           

  1. Active Account (gcloud CLI)                                                                                                                      
      • Account: YOUR_ACCOUNT                                                                                                                    
      • Status: Authenticated & Active                                                                                                                
  2. Project Configuration                                                                                                                            
      • Active Project: PROJECT_ID                                                                                                        
      • Quota Project: PROJECT_ID                                                                                                         
      • Compute Region: us-central1                                                                                                                   
  3. Project Access & Status                                                                                                                          
      • Project Name: PROJECT_ID                                                                                                                 
      • Project Number: PROJECT_NUMBER                                                                                                                  
      • Lifecycle State: ACTIVE                                                                                                                       
      • Permissions: Verified (able to retrieve project metadata via Resource Manager API).                                                           
  4. Application Default Credentials (ADC)                                                                                                            
      • Status: Active & Valid (client SDKs and application libraries can successfully authenticate to Google Cloud APIs).

2. Architectural Auth Decisions

You prompt: What authentication method should I use for a Cloud Run service that needs to access BigQuery?

Agent response: (Which skill did it use? Answer comes a bit later)

For a Cloud Run service accessing BigQuery, the recommended Google Cloud best practice is Service-to-Service Authentication via attached Service    
  Accounts.                                                                                                                                           
  ──────                                                                                                                                              
  ### Recommended Setup                                                                                                                               

  #### 1. Authentication (Identity)                                                                                                                   

  Attach a Custom User-Managed Service Account to your Cloud Run service instead of using default accounts or static JSON key files.                  

  • Create a custom service account (e.g., cloud-run-bq-sa@<project-id>.iam.gserviceaccount.com).                                                     
  • Attach it to Cloud Run during deployment:                                                                                                         
    gcloud run deploy SERVICE_NAME \                                                                                                                  
      --image IMAGE_URL \                                                                                                                             
      --service-account cloud-run-bq-sa@PROJECT_ID.iam.gserviceaccount.com                                                                            


  │ ⚠️ Avoid using static Service Account Keys (JSON files). Cloud Run provides a secure local metadata server that handles token issuance dynamically.
  ──────                                                                                                                                              
  #### 2. Authorization (IAM Roles)                                                                                                                   

  Grant your service account the least-privilege IAM roles required for BigQuery:                                                                     

  • roles/bigquery.jobUser: Required to run query jobs in the project.                                                                                
  • roles/bigquery.dataViewer (or roles/bigquery.dataEditor): Required to read (or write) data in the specific dataset or tables.                     

    # Grant permission to run jobs in the project                                                                                                     
    gcloud projects add-iam-policy-binding PROJECT_ID \                                                                                               
      --member="serviceAccount:cloud-run-bq-sa@PROJECT_ID.iam.gserviceaccount.com" \                                                                  
      --role="roles/bigquery.jobUser"                                                                                                                 

    # Grant permission on the dataset                                                                                                                 
    gcloud bigquery datasets add-iam-policy-binding DATASET_NAME \                                                                                    
      --member="serviceAccount:cloud-run-bq-sa@PROJECT_ID.iam.gserviceaccount.com" \                                                                  
      --role="roles/bigquery.dataViewer"                                                                                                              
    ──────                                                                                                                                            
  #### 3. In-Code Access (Application Default Credentials)                                                                                            

  In your application code, initialize the official Google Cloud BigQuery client library without passing explicit credentials. The library            
  automatically retrieves tokens via Application Default Credentials (ADC) from the Cloud Run metadata server.                                        

  Python Example:                                                                                                                                     

    from google.cloud import bigquery                                                                                                                 

    # Automatically authenticates using the attached service account                                                                                  
    client = bigquery.Client(project="PROJECT_ID")                                                                                        

    query_job = client.query("SELECT 1 AS test")                                                                                                      
    results = query_job.result()

I asked Antigravity CLI the following question: how did you answer the above question?

And here is the response. Check how it used the other skill:

I answered the question by drawing on Google Cloud's Security Best Practices (documented in the SKILL.md skill):                                    

  1. Authentication Framework (Identity)                                                                                                              
      • Google Cloud recommends using managed service identities for production workloads rather than static credentials (like JSON key files).       
      • In Cloud Run, attaching a custom service account allows the instance metadata server to issue short-lived access tokens dynamically.          
  2. IAM Authorization Model (Permissions)                                                                                                            
      • Google Cloud IAM enforces the principle of least privilege.                                                                                   
      • Accessing BigQuery requires separating job execution rights (roles/bigquery.jobUser) from data access rights (roles/bigquery.dataViewer or    
      dataEditor).                                                                                                                                    
  3. Application Default Credentials (ADC)                                                                                                            
      • Standard Google Cloud Client Libraries automatically search for credentials in a predefined hierarchy.                                        
      • On Cloud Run, ADC automatically retrieves tokens from the attached service account via the internal metadata server (http://169.254.169.254), 
      making hardcoded credentials unnecessary.

3. Setting up a Service Account

Try out things like this Help me set up a service account for my Cloud Run application with minimal permissions to access BigQuery

BigQuery Skills

In this step, we’ll explore how to use Agent Skills to interact with Google BigQuery. Instead of manually writing bash scripts, SQL queries, or Python clients, we will rely entirely on our AI agent.

Confirming Skill Installation

For this step, we will use the bigquery-basics skill. Confirm it's installed:

npx skills list

Prompt-Driven BigQuery Operations

With the bigquery-basics skill, the agent understands how to manage datasets, create tables, insert data, and run analytical queries.

1. Creating a Dataset

You prompt: Create a new BigQuery dataset called skills_tutorial in my project PROJECT_ID

Agent response:

The BigQuery dataset skills_tutorial has been successfully created in project PROJECT_ID.                                               

  ### Dataset Details:                                                                                                                                

  • Dataset ID: PROJECT_ID:skills_tutorial                                                                                                
  • Location: US                                                                                                                                      
  • Type: DEFAULT                                                                                                                                     
  • Status: Active (Verified)

Creating a Table

You prompt: Now create a table called web_analytics in that dataset with columns for: event_timestamp (TIMESTAMP), page_url (STRING), user_id (STRING), session_duration_seconds (FLOAT64), country (STRING)

Agent response:

The BigQuery table web_analytics has been successfully created in dataset skills_tutorial.                                                          

  ### Table Details:                                                                                                                                  

  • Table ID: PROJECT_ID:skills_tutorial.web_analytics                                                                                    

  ### Schema:                                                                                                                                         

   Column Name │ Type │ Mode
  ─────────────────────────────────────────────────┼─────────────────────────────────────────────────┼────────────────────────────────────────────────
   event_timestamp │ TIMESTAMP │ NULLABLE
   page_url │ STRING │ NULLABLE
   user_id │ STRING │ NULLABLE
   session_duration_seconds │ FLOAT64 │ NULLABLE
   country │ STRING │ NULLABLE

3. Inserting Sample Data

You prompt: Insert 10 rows of realistic sample web analytics data into the web_analytics table

Agent response:

10 realistic sample rows have been inserted into PROJECT_ID:skills_tutorial.web_analytics.                                              

  ### Inserted Data Preview:                                                                                                                          

   event_timestamp │ page_url │ user_id │ session_duration_seconds │ country
  ───────────────────────────┼─────────────────────────────────────┼───────────────────────────┼───────────────────────────┼──────────────────────────
   2026-07-23 10:15:30 UTC │ https://example.com/home │ usr_1001 │ 45.2 │ US
   2026-07-23 10:18:12 UTC │ https://example.com/products/laptop │ usr_1002 │ 120.8 │ CA
   2026-07-23 11:02:45 UTC │ https://example.com/blog/ai-trends │ usr_1003 │ 310.5 │ GB
   2026-07-23 11:45:00 UTC │ https://example.com/cart │ usr_1001 │ 88.0 │ US
   2026-07-23 12:30:15 UTC │ https://example.com/checkout │ usr_1004 │ 215.3 │ DE
   2026-07-23 13:10:05 UTC │ https://example.com/home │ usr_1005 │ 15.6 │ IN
   2026-07-23 14:05:22 UTC │ https://example.com/pricing │ usr_1006 │ 175.4 │ JP
   2026-07-23 14:22:10 UTC │ https://example.com/docs/api │ usr_1007 │ 450.0 │ US
   2026-07-23 15:00:50 UTC │ https://example.com/about │ usr_1008 │ 62.1 │ FR
   2026-07-23 15:40:18 UTC │ https://example.com/contact │ usr_1009 │ 95.7 │ AU

4. Running Analytical Queries

You prompt: Query the web_analytics table to show me the top 5 countries by average session duration

Agent response:

Here are the top 5 countries by average session duration from the web_analytics table:                                                              

  ### Query Results:                                                                                                                                  

                  Rank │ Country │ Average Session Duration (seconds) │ Total Sessions
  ─────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────
                    1 │ United Kingdom (GB) │ 310.50 s │ 1
                    2 │ Germany (DE) │ 215.30 s │ 1
                    3 │ United States (US) │ 194.40 s │ 3
                    4 │ Japan (JP) │ 175.40 s │ 1
                    5 │ Canada (CA) │ 120.80 s │ 1
  ──────                                                                                                                                              
  ### Executed SQL Query:                                                                                                                             

    SELECT                                                                                                                                            
      country,                                                                                                                                        
      ROUND(AVG(session_duration_seconds), 2) AS avg_session_duration_seconds,                                                                        
      COUNT(*) AS total_sessions                                                                                                                      
    FROM `PROJECT_ID.skills_tutorial.web_analytics`                                                                                       
    GROUP BY country                                                                                                                                  
    ORDER BY avg_session_duration_seconds DESC                                                                                                        
    LIMIT 5;

5. Complex Aggregations

You prompt: Show me a query that calculates daily page view counts grouped by URL

Agent response:

Here is the SQL query to calculate daily page view counts grouped by URL, along with unique visitor metrics:                                        

  ### SQL Query:                                                                                                                                      

    SELECT                                                                                                                                            
      DATE(event_timestamp) AS event_date,                                                                                                            
      page_url,                                                                                                                                       
      COUNT(*) AS page_views,                                                                                                                         
      COUNT(DISTINCT user_id) AS unique_visitors                                                                                                      
    FROM `PROJECT_ID.skills_tutorial.web_analytics`                                                                                       
    GROUP BY                                                                                                                                          
      event_date,                                                                                                                                     
      page_url                                                                                                                                        
    ORDER BY                                                                                                                                          
      event_date DESC,                                                                                                                                
      page_views DESC;                                                                                                                                
    ──────                                                                                                                                            
  ### Execution Results:                                                                                                                              

   Event Date │ Page URL │ Page Views │ Unique Visitors
  ────────────────────────────────────┼─────────────────────────────────────┼────────────────────────────────────┼────────────────────────────────────
   2026-07-23 │ https://example.com/home │ 2 │ 2
   2026-07-23 │ https://example.com/products/laptop │ 1 │ 1
   2026-07-23 │ https://example.com/blog/ai-trends │ 1 │ 1
   2026-07-23 │ https://example.com/cart │ 1 │ 1
   2026-07-23 │ https://example.com/checkout │ 1 │ 1
   2026-07-23 │ https://example.com/pricing │ 1 │ 1
   2026-07-23 │ https://example.com/docs/api │ 1 │ 1
   2026-07-23 │ https://example.com/about │ 1 │ 1
   2026-07-23 │ https://example.com/contact │ 1 │ 1

6. Cleanup

You prompt: Clean up i.e. delete the skills_tutorial dataset

Agent response:

The dataset skills_tutorial (and its contained web_analytics table) has been successfully deleted from project PROJECT_ID.              

  ### Clean-Up Summary:                                                                                                                               

  • Deleted Dataset: PROJECT_ID:skills_tutorial                                                                                           
  • Verification Status: Confirmed deleted (Not found).

Notice how you never had to write SQL or learn the bq CLI. The agent did it all.

Cloud Run Deployment

In this step, we’ll deploy a Python application to Google Cloud Run, a fully managed compute platform that automatically scales your stateless containers. Instead of writing the code, containerizing it, and deploying it manually, we’ll let the AI agent handle the entire process.

Confirming Skill Installation

For this step, we will use the cloud-run-basics skill. Confirm it's installed:

npx skills list

Prompt-Driven Application Deployment

With the cloud-run-basics skill, the agent knows how to write application code, create optimized Dockerfiles, and deploy to Cloud Run using best practices.

1. Generating the Application Code

You prompt: Create a simple Flask web API with three endpoints: GET / (returns service info), GET /health (returns OK), and POST /analyze (accepts JSON with a text field and returns word count and character count)

Agent response:

The Flask Web API has been created in app.py and verified with tests in test_app.py.                                                                

  ### API Endpoints Summary                                                                                                                           

  1. GET /                                                                                                                                            
      • Description: Returns service information and endpoints metadata.                                                                              
      • Response:                                                                                                                                     
        {                                                                                                                                             
          "service": "Text Analysis Web API",                                                                                                         
          "version": "1.0.0",                                                                                                                         
          "status": "running",                                                                                                                        
          "endpoints": [...]                                                                                                                          
        }                                                                                                                                             

  2. GET /health                                                                                                                                      
      • Description: Health check endpoint.                                                                                                           
      • Response: {"status": "OK"} (HTTP 200)                                                                                                         
  3. POST /analyze                                                                                                                                    
      • Description: Accepts a JSON body containing a text string field and returns word count and character count.                                   
      • Sample Request:                                                                                                                               
        curl -X POST http://localhost:8080/analyze \                                                                                                  
          -H "Content-Type: application/json" \                                                                                                       
          -d '{"text": "Hello world from Flask API!"}'                                                                                                

      • Sample Response:                                                                                                                              
        {                                                                                                                                             
          "text": "Hello world from Flask API!",                                                                                                      
          "word_count": 5,                                                                                                                            
          "character_count": 27                                                                                                                       
        }                                                                                                                                             


  ──────                                                                                                                                              
  ### How to Run locally                                                                                                                              

    ./.venv/bin/python3 app.py

2. Containerizing the App

You prompt: Create a Dockerfile for this Flask application

Agent response:

The Dockerfile, .dockerignore, and requirements.txt have been created.                                                                              

  ### Dockerfile Contents:                                                                                                                            

    # Use official lightweight Python image                                                                                                           
    FROM python:3.11-slim                                                                                                                             

    # Prevent Python from writing .pyc files and buffer stdout/stderr                                                                                 
    ENV PYTHONUNBUFFERED=1 \                                                                                                                          
        PYTHONDONTWRITEBYTECODE=1 \                                                                                                                   
        PORT=8080                                                                                                                                     

    # Set working directory                                                                                                                           
    WORKDIR /app                                                                                                                                      

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

    # Copy application source code                                                                                                                    
    COPY app.py .                                                                                                                                     

    # Expose port                                                                                                                                     
    EXPOSE 8080                                                                                                                                       

    # Run the web service using Gunicorn                                                                                                              
    CMD exec gunicorn --bind 0.0.0.0:$PORT --workers 1 --threads 8 --timeout 0 app:app                                                                
    ──────                                                                                                                                            
  ### Key Highlights:                                                                                                                                 

  • Production WSGI: Configured with gunicorn for high performance and concurrency.                                                                   
  • Cloud Run Compatible: Listens on dynamic $PORT (defaulting to 8080).                                                                              
  • Optimized Build: .dockerignore created to exclude virtual environments, cache files, and unnecessary repository metadata.

Deploying to Cloud Run

You prompt: Deploy this application to Cloud Run in us-central1 region as a service called skills-tutorial-analyzer

Agent response:

The deployment command for skills-tutorial-analyzer to Cloud Run in us-central1 has been launched in the background. I will wait for it to complete 
  before proceeding.....

The Flask application has been successfully built and deployed to Cloud Run!                                                                        

  ### Deployment Details:                                                                                                                             

  • Service Name: skills-tutorial-analyzer                                                                                                            
  • Region: us-central1                                                                                                                               
  • Project: PROJECT_ID                                                                                                                   
  • Service URL: [https://skills-tutorial-analyzer-<PROJECT-NUMBER>.us-central1.run.app](https://skills-tutorial-analyzer-415458962931.us-central1.run.app)                                                                    
  ──────                                                                                                                                              
  ### Verified Endpoints:                                                                                                                             

  #### 1. Service Information (GET /)                                                                                                                 

    curl https://skills-tutorial-analyzer-<PROJECT-NUMBER>.us-central1.run.app/                                                                           

  Response:                                                                                                                                           

    {                                                                                                                                                 
      "service": "Text Analysis Web API",                                                                                                             
      "version": "1.0.0",                                                                                                                             
      "status": "running",                                                                                                                            
      "endpoints": [...]                                                                                                                              
    }                                                                                                                                                 

  #### 2. Health Check (GET /health)                                                                                                                  

    curl https://skills-tutorial-analyzer-<PROJECT-NUMBER>.us-central1.run.app/health                                                                     

  Response:                                                                                                                                           

    {                                                                                                                                                 
      "status": "OK"                                                                                                                                  
    }                                                                                                                                                 

  #### 3. Text Analysis (POST /analyze)                                                                                                               

    curl -X POST https://skills-tutorial-analyzer-<PROJECT_NUMBER>.us-central1.run.app/analyze \                                                          
      -H "Content-Type: application/json" \                                                                                                           
      -d '{"text": "Hello world from deployed Cloud Run service!"}'                                                                                   

  Response:                                                                                                                                           

    {                                                                                                                                                 
      "text": "Hello world from deployed Cloud Run service!",                                                                                         
      "word_count": 7,                                                                                                                                
      "character_count": 44                                                                                                                           
    }

4. Testing the Health Endpoint

You prompt: What’s the URL of my deployed service? Test it by hitting the health endpoint

Agent response:

The URL of your deployed Cloud Run service is:                                                                                                      

  🔗 https://skills-tutorial-analyzer-<PROJECT-NUMBER>.us-central1.run.app                                                                                
  ──────                                                                                                                                              
  ### Health Endpoint Test (GET /health)                                                                                                              

    curl -i https://skills-tutorial-analyzer-<PROJECT-NUMBER>.us-central1.run.app/health                                                                  

  #### Response:                                                                                                                                      

    HTTP/2 200                                                                                                                                        
    content-type: application/json                                                                                                                    
    date: Thu, 23 Jul 2026 10:43:31 GMT                                                                                                               
    server: Google Frontend                                                                                                                           

    {"status":"OK"}

5. Testing the Analyze Endpoint

You prompt: Send a POST request to the /analyze endpoint with the text ‘Google Cloud Skills make AI agents powerful’

Agent response:

Here is the response from sending the POST request to the /analyze endpoint:                                                                        

  ### Request:                                                                                                                                        

    curl -X POST https://skills-tutorial-analyzer-<PROJECT-NUMBER>.us-central1.run.app/analyze \                                                          
      -H "Content-Type: application/json" \                                                                                                           
      -d '{"text": "Google Cloud Skills make AI agents powerful"}'                                                                                    
    ──────                                                                                                                                            
  ### Response (HTTP 200 OK):                                                                                                                         

    {                                                                                                                                                 
      "text": "Google Cloud Skills make AI agents powerful",                                                                                          
      "word_count": 7,                                                                                                                                
      "character_count": 43                                                                                                                           
    }

6. Cleanup

You prompt: Delete the skills-tutorial-analyzer Cloud Run service to clean up

Agent response:

The deletion command for Cloud Run service skills-tutorial-analyzer has been launched in the background. I will wait for it to complete before      
  proceeding.                                                                                                                                         

....
....

  The Cloud Run service skills-tutorial-analyzer has been successfully deleted from region us-central1 in project PROJECT_ID.             

  ### Clean-Up Verification:                                                                                                                          

  • Service Name: skills-tutorial-analyzer                                                                                                            
  • Region: us-central1                                                                                                                               
  • Status: Deleted (Verified via gcloud run services describe)

The agent wrote the code, containerized it, deployed it, and tested it — all from natural language.

To summarize

You have seen how to use Google Cloud Agent Skills now. The next part of the series will cover a few advanced skills around Architecture, Security and even writing your own Custom Skill. Stay tuned.

Google Cloud Skills Tutorial: The Complete Guide to AI-Powered Cloud Operations

Romin Irani — Thu, 23 Jul 2026 11:11:46 +0000

Welcome to the definitive guide on Google Cloud Agent Skills. As the landscape of software engineering evolves, AI coding agents are increasingly being given tasks to becoming autonomous and capable of executing complex, multi-step cloud operations.

The goal of this series is to take a look at the current set of official skills being made available by Google Cloud, right from the basics and applying it to a few use cases like performing security audits, deploy serverless applications, or optimize BigQuery pipelines.

At the end of this series, you should be able to assess their readiness and be able to leverage a few of these Agents Skills to get the job done accurately and securely.

Generated by Gemini Notebook

The Series:

- Part 1 : What are Google Cloud Skills (this blog)

_- Part 2 : Intermediate Skills in Action (BigQuery and Cloud Run)

Part 3 : Advanced Ops (WAF Security, Architecture, Custom Skills)

Part 4 : More Use Cases_

What Are Google Cloud Skills?

Agent Skills act as the essential bridge between raw AI capabilities and structured cloud expertise. They are portable instruction sets that teach AI coding agents exactly how to work with specific technologies safely and efficiently.

Instead of an agent blindly guessing a gcloud command and breaking a production cluster, a skill provides:

Verified Workflows : Step-by-step logic approved by experts.
Safety Gates : Clear distinctions between read-only audits and mutating actions that require your explicit human-in-the-loop approval.
Contextual Awareness : Instructions on what environmental variables, IAM permissions, and authentication states to check before beginning a task.

That is our understanding and expectations. At the end of the day, results will vary, depending on the quality of the Skills. Hence an important area like Cloud Operations , if using with Agent Skills, will have to be evaluated carefully.

The google/skills Repository

The official google/skills repository is an open-source collection of these instruction sets. Built on the open standard defined at agentskills.io, it currently houses (at the time of writing) nearly 70+ skills spanning 8 distinct categories:

How Skills Work: The Progressive Disclosure Model

If you were to load all 70 odd instructions/details that are present in these skills into an AI agent’s context window simultaneously, the agent would become confused, slow, and expensive to run. To solve this, when it comes to Skills, Agents will use a progressive disclosure model.

Enough has been written on this topic, so we will not iterate much on that here.

Getting Started

This section summarizes the foundational setup required to start using Google Skills. We will explore how to get your agent environment set up with these powerful instruction sets.

Prerequisites

Before we install anything, ensure you have the following installed on your machine:

Node.js (v18+): Required for running the skills CLI.
npm : Comes with Node.js.
Google Cloud SDK (gcloud CLI): To authenticate and interact with Google Cloud. You should setup gcloud with a specific Google Cloud Project, so that all the experiments that you do with these Agent Skills will be executed across that project.
An AI coding agent : E.g., Google Antigravity / Antigravity CLI or any other agent that supports the agentskills.io standard.

Installing Skills

Getting the skills onto your machine is straightforward. Ensure you have Node.js (v18+) and your AI coding agent installed. You could install specific skills that you need via the npx skills add google/skills command. But here are some ways to install the skills.

Option A: Install Only What This Tutorial Needs (Recommended)

For this tutorial, we use 9 specific skills across the steps and use cases. Installing only these keeps your environment focused and is a best practice, you should install what you need, not everything.

You can use the interactive CLI to install skills:

# Core setup skills 
npx skills add google/skills --skill google-cloud-recipe-onboarding
npx skills add google/skills --skill google-cloud-recipe-auth

# Intermediate skills
npx skills add google/skills --skill bigquery-basics
npx skills add google/skills --skill cloud-run-basics

# Advanced skills 
npx skills add google/skills --skill google-cloud-waf-security
npx skills add google/skills --skill google-cloud-solution-architecture

# Use Case skills
npx skills add google/skills --skill google-cloud-waf-cost-optimization
npx skills add google/skills --skill google-cloud-solution-build-deploy-agents
npx skills add google/skills --skill gemini-api

Starting with just these 9 skills is ideal for learning. You can always add more later as you explore.

For example, when I run the first command , I get the following interactive display:

$ npx skills add google/skills --skill google-cloud-recipe-onboarding

███████╗██╗ ██╗██╗██╗ ██╗ ███████╗
██╔════╝██║ ██╔╝██║██║ ██║ ██╔════╝
███████╗█████╔╝ ██║██║ ██║ ███████╗
╚════██║██╔═██╗ ██║██║ ██║ ╚════██║
███████║██║ ██╗██║███████╗███████╗███████║
╚══════╝╚═╝ ╚═╝╚═╝╚══════╝╚══════╝╚══════╝

┌ skills 
│
◇ Source: https://github.com/google/skills.git
│
◇ Repository cloned
│
◇ Found 84 skills
│
● Selected 1 skill: google-cloud-recipe-onboarding
│
◇ 75 agents
◆ Which agents do you want to install to?
│
│ ── Universal (.agents/skills) ── always included ────────────
│ • Amp
│ • Antigravity
│ • Antigravity CLI
│ • Cline
│ • Codex
│ • Cursor
│ • Deep Agents
│ • Gemini CLI
│ • GitHub Copilot
│ • Kimi Code CLI
│ • OpenCode
│ • Warp
│ • Zed
│ …and 4 more
│
│ ── Additional agents ─────────────────────────────
│ Search:  
│ ↑↓ move, space select, enter confirm
│
│ ❯ ○ AiderDesk (.aider-desk/skills)
│ ○ AstrBot (data/skills)
│ ○ Autohand Code CLI (.autohand/skills)
│ ○ Augment (.augment/skills)
│ ○ IBM Bob (.bob/skills)
│ ○ Claude Code (.claude/skills)
│ ○ OpenClaw (skills)
│ ○ CodeArts Agent (.codeartsdoer/skills)
│ ↓ 47 more
│
│ Selected: Amp, Antigravity, Antigravity CLI +10 more

It then asks you for Global or Project scope. It is advisable to go ahead with the current folder i.e. Project scope. This will create a .agents/skills folder and the skills will be placed in that.

Finally, you should see an overall report on the installation:

◇ Installation scope
│ Project

│
◇ Installation Summary ─────────────────────────────────────────────────────────────────╮
│ │
│ ~/agy2-projects/google-skills-tutorial/.agents/skills/google-cloud-recipe-onboarding │
│ copy → Amp, Antigravity, Antigravity CLI, Cline, Codex +8 more │
│ │
├────────────────────────────────────────────────────────────────────────────────────────╯
│
◇ Security Risk Assessments ────────────────────────────────────────────────────╮
│ │
│ Gen Socket Snyk │
│ google-cloud-recipe-onboarding Safe 0 alerts Low Risk │
│ │
│ Details: https://skills.sh/google/skills │
│ │
├────────────────────────────────────────────────────────────────────────────────╯
│
◇ Proceed with installation?
│ Yes
│
◇ Installation complete

│
◇ Installed 1 skill ────────────────────────────────────────────────────────────────────────╮
│ │
│ ✓ google-cloud-recipe-onboarding (copied) │
│ → ~/agy2-projects/google-skills-tutorial/.agents/skills/google-cloud-recipe-onboarding │
│ │
├────────────────────────────────────────────────────────────────────────────────────────────╯

│
└ Done! Review skills before use; they run with full agent permissions.

Here ~/agy2-projects/google-skills-tutorial/ is my folder in which I am running this tutorial. This could be something different on your machine.

Option B : Install Additional Skills (Later)

If you want the full catalogue and prefer to explore on your own, use the interactive installer: If you want the full catalogue and prefer to explore on your own, use the interactive installer:

npx skills add google/skills

When you run this command, an interactive selector will appear in your terminal. Choose the specific skills that you are interested to install and try out.

Option C : Installing a Single Skill Later (npx command based)

If you discover you need an additional skill later, you can add it individually at any time:

npx skills add google/skills --skill bigquery-basics

Manual Installation

If you prefer full control, you can clone the repository or manually place skill folders in your environment. Skills can be installed in two locations depending on their intended scope:

Workspace-specific : Place the skill folder inside .agents/skills/ at the root of your current project.
Global (User level): Place the skill folder inside ~/.gemini/config/skills/ to make it available across all your projects.

Where Skills get installed

When your agent starts up, it looks for skills across several locations. It resolves them using a specific hierarchy. If a skill with the same name exists in multiple places, the one closest to the workspace takes precedence.

Verification

After installation, it is good practice to verify that everything is in order.

You can list all currently installed and active skills using:

npx skills list

You should see something similar to this:

$ npx skills list
Project Skills

bigquery-basics ~/agy2-projects/google-skills-tutorial/.agents/skills/bigquery-basics                          
  Agents: Antigravity, Antigravity CLI, Gemini CLI Source: google/skills
cloud-run-basics ~/agy2-projects/google-skills-tutorial/.agents/skills/cloud-run-basics                         
  Agents: Antigravity, Antigravity CLI, Gemini CLI Source: google/skills
gemini-api ~/agy2-projects/google-skills-tutorial/.agents/skills/gemini-api                               
  Agents: Antigravity, Antigravity CLI, Gemini CLI Source: google/skills
google-cloud-recipe-auth ~/agy2-projects/google-skills-tutorial/.agents/skills/google-cloud-recipe-auth                 
  Agents: Antigravity, Antigravity CLI, Gemini CLI Source: google/skills
google-cloud-recipe-onboarding ~/agy2-projects/google-skills-tutorial/.agents/skills/google-cloud-recipe-onboarding           
  Agents: Antigravity, Antigravity CLI, Gemini CLI Source: google/skills
google-cloud-solution-architecture ~/agy2-projects/google-skills-tutorial/.agents/skills/google-cloud-solution-architecture       
  Agents: Antigravity, Antigravity CLI, Gemini CLI Source: google/skills
google-cloud-solution-build-deploy-agents ~/agy2-projects/google-skills-tutorial/.agents/skills/google-cloud-solution-build-deploy-agents
  Agents: Antigravity, Antigravity CLI, Gemini CLI Source: google/skills
google-cloud-waf-cost-optimization ~/agy2-projects/google-skills-tutorial/.agents/skills/google-cloud-waf-cost-optimization       
  Agents: Antigravity, Antigravity CLI, Gemini CLI Source: google/skills
google-cloud-waf-security ~/agy2-projects/google-skills-tutorial/.agents/skills/google-cloud-waf-security                
  Agents: Antigravity, Antigravity CLI, Gemini CLI Source: google/skills

Alternatively, you can just peek into your directory structure to ensure the SKILL.md files are present:

ls -la .agents/skills/

If you are using Antigravity CLI, you can launch Antigravity CLI ( agy ) from the terminal. Give it the /skills command and you should see the skills listed in the workspace.

Workspace skills · Workspace config
  bigquery-basics: Manages datasets, tables, and jobs in BigQuery. Use when you need to interact with BigQuery, run SQL queries, manage BigQuery resour...
  cloud-run-basics: Manages Cloud Run services, jobs, and worker pools. Use when you need to deploy applications responding to HTTP requests (services)...
  gemini-api: Use when the user asks about using Gemini in an enterprise environment or explicitly mentions Vertex AI, Google Cloud, or Agent Platform....
  google-cloud-recipe-auth: Provides expert guidance on authenticating and authorizing to Google Cloud services and APIs, covering human users, service...
  google-cloud-recipe-onboarding: Guides a developer's first steps on Google Cloud, covering account creation, billing setup, project management, and d...
  google-cloud-solution-architecture: Interactively discovers requirements for a specific cloud workload and generates design recommendations and archi...
  google-cloud-solution-build-deploy-agents: Designs, builds, and deploys AI agents or multi-agent systems on Google Cloud. Provides an interactive wor...
  google-cloud-waf-cost-optimization: Generates cost optimization guidance for Google Cloud workloads based on the Google Cloud Well-Architected Framew...
  google-cloud-waf-security: Generates security-focused guidance for Google Cloud workloads based on the design principles and recommendations in the G...

Managing Skills

The CLI provides simple commands for managing your installed skills over time:

Update skills : npx skills update
Remove a skill : npx skills remove google-cloud-recipe-onboarding
Find skills : npx skills find "cloud run"

Understanding Skill Anatomy

Once a skill is installed, what does it actually look like? In this step, we break down the structure of a skill following the agentskills.io standard.

The SKILL.md File

The heart of every skill is the SKILL.md file. This isn't just documentation, it is executable instruction code for AI coding agents. When an agent reads this file, it learns exactly how to perform tasks, what commands to run, and what safety checks to enforce.

Let’s look at the full contents of our sample-skill/SKILL.md and break down what each section does.

---
name: cloud-storage-lifecycle-manager
metadata:
  category: Storage
description: Use this skill when the user asks to manage, configure, or optimize Google Cloud Storage (GCS) bucket lifecycle policies and data retention rules.
---

> **Tutorial Note:** The frontmatter above is scanned by the agent on startup. The `description` acts as the trigger.

# Cloud Storage Lifecycle Manager

## Overview
This skill guides the agent in analyzing existing GCS buckets and applying XML or JSON lifecycle policies to transition objects to colder storage classes (Nearline, Coldline, Archive) or delete them to optimize costs.

> **Tutorial Note:** The overview sets the stage for the agent, clarifying its persona and objective.

## Prerequisites
Before executing any mutating commands, verify:
1. User is authenticated (`gcloud auth list`).
2. Current project is set to `PROJECT_ID` or the user-specified project.

## Workflow
1. **Assess:** List the target bucket's current policies using `gcloud storage buckets describe gs://<BUCKET_NAME> --format="json"`.
2. **Design:** Draft a lifecycle policy rule based on the user's requirements (e.g., transition to Coldline after 90 days).
3. **Confirm:** Present the proposed policy to the user for approval.
4. **Apply:** Apply the policy using `gcloud storage buckets update gs://<BUCKET_NAME> --lifecycle-file=<FILE.json>`.

> **Tutorial Note:** The workflow provides step-by-step instructions. Agents are highly capable of following numbered lists.

## Safety & Confirmation Tiers

- **Tier R (Read-only):** `gcloud storage ls`, `gcloud storage buckets describe`. You may run these without asking.
- **Tier M (Mutating):** Applying a new lifecycle policy. **MUST ASK FOR EXPLICIT CONFIRMATION.**
- **Tier D (Destructive):** Deleting objects or removing buckets. Refuse to do this unless explicitly mandated by the user.

> **Tutorial Note:** Safety tiers ensure the agent doesn't autonomously delete infrastructure.

## Workload Assessment Questions
If the user's request is vague, ask ONE of these questions at a time to clarify:
- "What is the name of the GCS bucket you want to apply the lifecycle rule to?"
- "After how many days should the objects transition to a colder storage class?"

## Validation
After applying the rule, verify success by running:
`gcloud storage buckets describe gs://<BUCKET_NAME> --format="value(lifecycle)"`
Ensure the output matches the applied rule.

YAML Frontmatter

Every SKILL.md begins with a YAML frontmatter block. This metadata is crucial for the agent's startup phase.

---
name: my-cloud-skill
metadata:
  category: Serverless
description: Use this skill when the user asks to deploy serverless applications.
---

name : A unique identifier for the skill (usually matches the folder name).
metadata.category : Groups skills logically.
description : This is the activation trigger. The agent uses semantic matching against this description to decide when to activate the skill based on the user's prompt.

Markdown Body Sections

The markdown body dictates the agent’s behavior. While highly flexible, Google Cloud skills typically follow a common pattern:

Overview / Quick Start : A brief explanation of the skill’s purpose.
Prerequisites : Tools or API access required before execution.
Workflow / Decision Trees : Step-by-step instructions the agent must follow.
Safety & Confirmation Tiers : Guidelines on what needs user approval:

Tier R (Read-only): Agent can run these without asking (e.g., gcloud compute instances list).
Tier M (Mutating): Agent must ask before applying changes.
Tier D (Destructive): Highly restrictive actions requiring extra confirmation (e.g., deleting buckets).

Workload Assessment Questions : Clarifying questions the agent should ask the user before beginning.
Validation Checklists : Steps to verify the task succeeded.

Optional Supporting Files

A skill folder isn’t limited to just SKILL.md. It can contain supporting directories:

references/: Detailed documentation, IaC patterns (Terraform), IAM policies, or MCP integration configs that the agent can read for deep context.
scripts/: Executable Bash/Python scripts for setup automation or verification.
assets/: Templates for outputs, configuration files, or architecture diagrams.

Skill Structure and Processing

The diagram below is a good way to visualize how the Agent at startup scans the Skills YAML frontmatter and then handles the loading of the skill accordingly.

Skill Categories Table

Google Cloud skills are broadly organized into 8 distinct categories, at the time of writing.

Your First Interaction

Now that you have skills installed and understand their anatomy, it’s time to see them in action.

How Skill Activation Works

AI coding agents use a progressive disclosure model to manage skills efficiently:

Startup : The agent rapidly scans only the YAML frontmatter of all installed skills. It builds an internal registry of description triggers.
Prompting : When you type a prompt, the agent evaluates it against the registry.
Activation : If a match is found, it loads the full SKILL.md into its context window and executes the defined workflow.

This prevents the agent’s context window from being overwhelmed with instructions for tools it doesn’t need for the current task.

Walkthrough: The Onboarding Skill

Let’s trace what happens when you trigger the google-cloud-recipe-onboarding skill.

User : “Help me get started with Google Cloud in my new project.”

Agent Matches Prompt : The agent determines this matches the onboarding skill.
Agent Reads SKILL.md : It loads the instructions.
Agent Asks Questions : Following the “Single-question policy” often defined in skills, it asks: “What is your target Google Cloud Project ID?”
User Answers : “Use MY_PROJECT_ID."
Agent Audits : The agent runs Tier R (read-only) commands like gcloud config list to check current authentication and project setup.
Agent Presents Confirmation Table : Before enabling billing or APIs, it presents a structured markdown table detailing what it plans to do.
Agent Waits : It halts execution and waits for your explicit “Yes” before proceeding with mutating actions.

Key Concepts

Safety Gates : Points in the workflow where the agent is explicitly instructed to stop and ask for permission.
Consent Tables : A structured format agents use to explain What they will do, Command they will run, and the Impact.
The Single-Question Policy : Best practice for skills dictating that agents should only ask the user one clarifying question at a time to prevent cognitive overload.

Example Prompts to Try

Ensure that you have launched your favourite Agent (Antigravity, Antigravity CLI or any other) from the folder in which the .agents/skills folder is present.

I suggest that you don’t run these prompts at the moment and just observe the kind of natural language prompts that you can use to work with Google Cloud Platform via these Google Agent Skills.

Category: Foundations

1. Trigger google-cloud-recipe-onboarding

Prompt: “I want to set up my first Google Cloud project from scratch.”

Explanation: The agent will guide you through project creation, billing linking, and initial IAM setup.

2. Trigger google-cloud-recipe-auth

Prompt: “How do I authenticate my local environment to Google Cloud?”

Explanation: The agent will walk you through gcloud auth login and Application Default Credentials (ADC).

Category: Serverless

3. Trigger cloud-run-basics

Prompt: “I have a Dockerfile here. Can you help me deploy a containerized app to Google Cloud?”

Explanation: The agent will ask for the service name and region, build the image, and run gcloud run deploy.

4. Trigger functions-basics

Prompt: “Help me deploy a Node.js function that triggers on Pub/Sub messages.”

Explanation: The agent will scaffold the function code and construct the deployment command with the correct trigger flags.

Category: Storage

5. Trigger cloud-storage-lifecycle-manager (Our custom skill!)

Prompt: “I need to automatically move objects in my GCS bucket to Archive storage after 1 year.”

Explanation: The agent will generate a JSON lifecycle policy and apply it after your confirmation.

Category: Databases

6. Trigger cloud-sql-basics

Prompt: “Spin up a PostgreSQL database on Cloud SQL and show me how to connect.”

Explanation: The agent will draft a gcloud sql instances create command and explain Cloud SQL Auth Proxy.

7. Trigger firestore-basics

Prompt: “Initialize a Firestore database in native mode for my web app.”

Explanation: The agent will set up the database and perhaps show you how to write basic security rules.

Category: Big Data & Analytics

8. Trigger bigquery-basics

Prompt: “Load this local CSV file into a new BigQuery table.”

Explanation: The agent will use the bq load command and verify the schema.

Category: Networking

9. Trigger vpc-networking

Prompt: “Create a custom VPC network with two subnets in us-central1 and us-east1.”

Explanation: The agent will map out the subnets, verify IP ranges, and execute the creation commands.

Category: Well Architected Framework

10. Trigger waf-security

Prompt: “Can you audit my current Google Cloud architecture to see if it is secure?”

Explanation: The agent will adopt an auditor persona, ask clarifying questions about your workloads, and check for public buckets, overly permissive IAM, etc.

The Series goes on

Stay tuned, as in Part 2, we will cover a couple of Skills in Action (BigQuery and Cloud Run).

Gemini 3.6 Flash & 3.5 Flash-Lite: Developer guide

Patrick Loeber — Thu, 23 Jul 2026 09:25:08 +0000

Gemini 3.6 Flash (gemini-3.6-flash) and Gemini 3.5 Flash-Lite (gemini-3.5-flash-lite) are generally available (GA) and ready for production use.

Gemini 3.6 Flash: Stronger performance on complex agentic and multimodal tasks while reducing token usage, at a lower price point than 3.5 Flash.
Gemini 3.5 Flash-Lite: The fastest, lowest-cost model in the 3.5 family. Outperforms prior Flash-Lite generations for high-throughput execution.

This guide explains what's new in each model, what API changes affect your code, and how to migrate.

Tip: You can automate this migration with a coding agent that supports skills (like Antigravity). Run /gemini-interactions-api migrate my app to Gemini 3.6 Flash

New models

Model	Model ID	Default thinking level	Pricing	Description
Gemini 3.6 Flash	`gemini-3.6-flash`	`medium`	$1.50/1M input tokens and $7.50/1M output tokens	Balances speed with intelligence for agentic and multimodal tasks.
Gemini 3.5 Flash-Lite	`gemini-3.5-flash-lite`	`minimal`	$0.30/1M input tokens and $2.50/1M output tokens	The fastest, lowest-cost 3.5 model for high-throughput execution.

Both models support the 1M token context window, 64k max output tokens, thinking, and the full suite of built-in tools including Computer Use.

For complete specs, see the model pages:

For detailed pricing, see the pricing page.

Quickstart

from google import genai

client = genai.Client()

interaction = client.interactions.create(
    model="gemini-3.6-flash",
    input="Write a three.js script that renders an interactive 3D robot."
)

print(interaction.output_text)

What's new in Gemini 3.6 Flash

Token and turn reduction: Completes multi-step workflows with fewer reasoning steps, conversational turns, and tool calls than Gemini 3.5. It also reduces execution loop spiraling.
Improved code generation: Produces higher quality production-ready code with fewer unwanted edits and fewer debugging loops.
Better instruction following: Reduces unwanted file changes during diagnostic tasks.
Strong multimodal and spatial reasoning: Improved performance on chart interpretation, visual blueprint conversion, and multi-element web layout generation.
Upfront programmatic inspection: Prefers running diagnostic code scripts before making changes more frequently than Gemini 3.5 Flash. This improves accuracy on complex tasks, but can add extra exploratory steps on simple frontend work.
Computer Use support: Supported as native tool for agentic UI automation.
UI styling preference: Better at creating functional code, though human evaluators preferred earlier models for visual layout and styling. You can mitigate this by providing explicit design guidelines.
Default thinking effort (medium): Uses the same medium default thinking level as Gemini 3.5 Flash.
Reduced pricing: Lower output token costs ($7.50/1M vs. $9.00/1M for 3.5 Flash). Input tokens remain at $1.50/1M.

What's new in Gemini 3.5 Flash-Lite

Reduced task execution latency: Highest throughput in the 3.5 family for high-volume data parsing and document extraction.
Enhanced reasoning and multimodal performance: Strong migration path from Gemini 2.5 Flash, with higher scores on reasoning tasks like HLE (18.0% vs. 11.0%) and multimodal benchmarks like CharXIV (74.5% vs. 63.7%).
Subagent orchestration and tool reliability: Improves tool execution reliability for code execution, search, and MCP workflows. Increase the thinking level for autonomous planning and complex subagent tasks.
Improved document understanding: Improves accuracy on document parsing and structured data extraction. Experiment with both minimal and high thinking levels depending on document complexity.
Interactive web coding and tabular data processing: Performs strongly on frontend JavaScript and tabular data processing by planning via lightweight code execution.
Chatbot and persona persistence: Stronger multi-turn instruction following and persona consistency over Gemini 3.1 Flash-Lite.
Computer Use support: Supported as native tool for agentic UI automation.

Choosing the right Flash or Flash-Lite model

Use this table to select the right model and migration path for your workloads.

Both models require removing deprecated sampling parameters (temperature, top_p, top_k) and prefilled model turns. See API changes for details.

Model	Primary use cases	Recommended migration target
Gemini 3.6 Flash `gemini-3.6-flash`	Code generation, spatial/multimodal reasoning, multi-step agentic workflows	Gemini 3.5 Flash, Gemini 3 Flash (Preview), or Gemini 3.1 Pro
Gemini 3.5 Flash-Lite `gemini-3.5-flash-lite`	Autonomous subagent execution, high-volume data analysis and document extraction, structured JSON parsing	Gemini 3.1 Flash-Lite or Gemini 2.5 Flash

Updated Antigravity agent

Due to its improved performance, Gemini 3.6 Flash is now the new default model powering the Antigravity agent in Gemini Managed Agents. This can be changed by setting a new field on the API.

from google import genai

client = genai.Client()

interaction = client.interactions.create(
    agent="antigravity-preview-05-2026",
    input="Read Hacker News, summarize the top 10 stories, and save the results as a PDF.",
    environment="remote",
)

print(interaction.output_text)

API changes and parameter updates

Starting with Gemini 3.6 Flash and Gemini 3.5 Flash-Lite, the following API changes apply to these models and all future Gemini model releases.

Sampling parameter deprecation: temperature, top_p, and top_k are deprecated. The API ignores these parameters and returns an error in future model generations.
Prefilled model turn validation: Prefilling model turns is no longer supported. If the last non-empty turn in the request is a model turn, the API returns a 400 error.

Below are detailed explanations and code samples for each API change.

1. Sampling parameter deprecation (`temperature`, `top_p`, `top_k`)

temperature, top_p, and top_k are deprecated and ignored. In future model generations, supplying these parameters returns an HTTP 400 error. Remove these parameters from all requests.

# ⚠️ Remove these parameters (deprecated)
generation_config = {
     "temperature": 0.7,
     "top_p": 0.9,
     "top_k": 40,
}

To improve determinism, define a system instruction with explicit rules for your
specific use case.

2. Prefilled model turn validation {:#prefilled-model-turn-validation}

API requests ending with a non-empty model role turn are disallowed and return an HTTP 400 Error.

⚠️ Avoid

In legacy generateContent or raw REST payloads, ending with a model role turn
is now disallowed:

/* ❌ DO NOT: End payload contents with a 'model' role turn */
{
  "contents": [
    {"role": "user", "parts": [{"text": "Translate 'Hello world' to Spanish."}]},
    {"role": "model", "parts": [{"text": "Translation:"}]}  /* ❌ Returns error */
  ]
}

✅ Recommended Migration (Interactions API)

In the Interactions API, model turns are not manually prefilled. If your application previously prefilled a model turn to suppress preambles or force JSON formatting, use system_instruction or Structured outputs instead.

# ✅ RECOMMENDED: Use system_instruction in the Interactions API to specify output format
interaction = client.interactions.create(
    model="gemini-3.6-flash",
    input="Translate 'Hello world' to Spanish.",
    system_instruction="Output only the translation without introductory text.",
)

Migration checklist

Tip: You can automate this migration with a coding agent that supports skills (like Antigravity). Run /gemini-interactions-api migrate my app to Gemini 3.6 Flash

Migrate to gemini-3.6-flash

Update Model ID: Change your target model string to gemini-3.6-flash.
Remove deprecated sampling parameters:
- Strip temperature, top_p, and top_k from generation configs.
- Replace thinking_budget with the string enum thinking_level set to "medium" or "high".
- Remove candidate_count (unsupported in Gemini 3.x).
Enforce turn validation rules:
- Standardize multi-turn conversations on server-side previous_interaction_id.
- Remove prefilled model turns.
Audit function calling:
- Place multimodal assets inside the response payload.
- Format inline instructions using \n\n.
- If you see Malformed_Function_Call errors tied to pre-tool text, see Workarounds for pre-tool text requirements.
- Only if using generateContent API: Ensure all FunctionResponse objects include call_id and name.
Baseline Gemini 3.x requirements: For SDK updates and thought signature preservation, see the Gemini 3.5 Migration Checklist.

Migrate to gemini-3.5-flash-lite

Update Model ID: Change your target model string to gemini-3.5-flash-lite.
Configure thinking effort level:
- For high-volume extraction, routing, or classification: leave thinking_level at "minimal" (default) for maximum throughput.
- For autonomous subagents with tool calls, code execution, or multi-step reasoning: set thinking_level to "medium" or "high" to prevent premature tool termination.
Remove deprecated parameters and validate function calling: Apply the same rules as for 3.6 Flash above.
Baseline Gemini 3.x requirements: Refer to the Gemini 3.5 Migration Checklist.

Next steps

Review API specs on the Models Overview.
Explore multi-agent orchestration in the Interactions API Guide.
Test and refine prompts in Google AI Studio.
Read the blog post, including info on the new Gemini 3.5 Flash Cyber model

Why AI Apps Fail in Production (And How Google Solved It)

Stephanie Wong — Wed, 22 Jul 2026 17:36:07 +0000

We are living in the golden age of the weekend AI side project. Thanks to vibe coding and LLMs, you can take a wild idea from a blank screen to a working app over a cup of coffee.

But the second you try to bring that casual prototype into a big enterprise environment, you hit a brick wall. Rigid infrastructure, strict compliance rules, and a leadership team terrified of breaking things will kill your momentum.

The numbers are pretty brutal: Only 5% of AI prototypes ever make it to production. The other 95% vanish into corporate purgatory.

Watching people on social media ship lightning-fast AI features while you're stuck in endless corporate review loops can be maddening. To figure out how to bridge that gap, I looked into the engineering trenches at YouTube to see how they handle this exact speed-vs-risk paradox.

The Speed-vs-Risk Paradox

When you're building solo, failure is cheap. If your AI agent acts up, you just tweak the prompt and hit restart.

But inside a company, letting unconstrained AI agents run loose creates a massive blast radius. On our premiere episode of Emergent, AI engineering leader Addy Osmani talked about running ten parallel agents on a personal project. Because the changes weren't properly isolated, technical debt piled up instantly and catastrophically broke two of his apps.

Now imagine that risk at YouTube’s scale, where you're handling billions of users on a 20-year-old codebase. You can't just let experimental code run wild. But traditional compliance pipelines take months, and by the time your demo actually gets approved, the AI models have already evolved, leaving your feature obsolete.

Enter YouTube’s AI Prototyping Stack

Benji Bear, Google Deepmind and former YouTube engineer, solved this problem by changing the infrastructure philosophy entirely. Instead of trying to speed up manual reviews, his team decoupled experimentation from mainline production servers.

They built a Prototyping Stack that tackles the two biggest bottlenecks for developers:

A Safe, Live Data Layer: Instead of testing in a vacuum with fake data, developers bootstrap ideas using Google AI Studio templates. These hook into a secure Google Cloud proxy server that grants pre-authenticated, read-only API access to live components - like playlists, videos, and channels. You get technical accuracy without any risk of polluting or crashing core databases.

Live UI Injection: To see how features actually feel to a real user, developers use client-side extension wrappers to inject experimental UI directly into their local browser. It's completely isolated from production code, meaning updates can be safely staged and tested in minutes.

By shifting to this setup, YouTube went from taking quarters to vet a single feature to launching several successful prototypes (like YouTube Recap) straight to user research studies in a matter of weeks.

Embrace Throw-Away Code

Making this work requires a pretty massive psychological shift: You have to embrace throw-away code.

As engineers, we are trained to write pristine, permanent infrastructure. But prototype code should be messy. Its only goal is to validate whether users actually care about the feature. Trying to clean up and force a chaotic, AI-generated script directly into an enterprise codebase is an architectural trap.

Instead, you can use Google AI Studio to establish a highly accurate baseline on day one. Run your user tests, look at the data, and if the idea wins, discard the messy script. Because you already proved the baseline parameters work, rewriting a clean version for production becomes significantly faster, cheaper, and safer.

Moving Fast Without Breaking Things

A 95% failure rate shouldn't be viewed as a mistake—it should be the strategy. AI has made generating code incredibly cheap, shifting our roles from syntax gatekeepers to System Architects.

Our job now is to design the read-only sandboxes and isolated pipelines that let our teams fail safely at hyper-speed. The biggest risk isn't breaking a server with messy AI code; it's missing the technological wave because your validation loops are too slow.

To see the full technical breakdown, developer interviews, and a deep dive into the AI Prototyping Stack, check out our premiere episode of Emergent on YouTube.

Google Cloud Labs: Accelerate AI with Cloud Run

Shir Meir Lador — Tue, 21 Jul 2026 13:00:00 +0000

Moving Beyond the Prototype

The AI landscape has shifted. While "vibe coding" with tools like Antigravity and AI Studio lets you build and deploy complex agents in minutes, the real work begins on "Day 2". Moving from a magical prototype to a hardened, production-grade application requires professional AI engineering. We're excited to bring back the Accelerate AI with Cloud Run roadshow for 2026. This year, we've updated our curriculum to focus on the full AI agent lifecycle, giving you the keys to productionizing and scaling agentic workloads on Google Cloud's serverless platform.

The Coffee Shop Journey: A Hands-On Experience

Experience the ease of building advanced AI agents on Cloud Run through 'The Coffee Shop Journey'. This interactive session is designed to guide you through the full lifecycle of an AI agent, moving beyond prototyping to focus on real business use cases. You will solve real-world business problems as you evolve from launching a simple cafe to building complex, intelligent assistants.

Our curriculum covers the core pillars of modern AI development:

The Basics: Gain familiarity with Cloud Run by deploying a simple web app (a Coffee Shop launch scenario) to understand the platform fundamentals.
Build a Coffee Recommendation Agent: Create a personalized AI assistant using Google's Agent Development Kit (ADK) and Retrieval-Augmented Generation (RAG).
Optimize Coffee Stand Locations: Use Gemma 4 and the BigQuery MCP server to identify the most profitable locations for new coffee stands by analyzing popular bike routes.
Personal Productivity Assistant for Store Managers: Create a personal productivity assistant using Cloud Run to help a coffee shop manager with daily operational tasks and scheduling.
Master Advanced Features with Antigravity 2.0: Learn how to use skills, context, rules, and hooks with Antigravity 2.0 to build new features for your Cloud Run applications.

Production-Grade AI on Cloud Run

Get first-hand experience with the platform innovations that make Cloud Run the ideal home for production-grade agentic workloads. Through hands-on exercises, you will learn to build, scale, and orchestrate long-running agents using Google's ADK and Antigravity 2.0. Additionally, you will utilize BigQuery MCP for automated, data-driven expansion strategies, and experience low-latency inference for frontier models using Cloud Run's GPU offerings without the traditional overhead of cluster management.

Ready to Build for Scale? Join us in North America

Don't just witness the AI revolution - build it. Find the workshop in your city and secure your spot today! Let's transform your AI journey from a simple prototype into a powerful, production reality.

City	Date	Registration Link
Atlanta, GA (as a part of Atlanta Tech week)	August 12-13	https://www.renderatl.com/tickets Event tickets grant access to the workshops on a first-come, first-served basis.
Sunnyvale, CA	August 13	Register now!
Toronto, Canada	August 27	Register now!
Seattle, WA	September	Registration opens late July!
New York City, NY	October	Registration opens late July!
Los Angeles, CA	November	Registration opens late July!
Boston, MA	October	Registration opens late July!
Washington D.C.	October	Registration opens late July!

Registration Update: Links for our September, October, and November workshops will be added to this page in late July. Stay tuned!

What is an "agentic harness," actually?

Tilde A. Thurium — Thu, 16 Jul 2026 21:19:20 +0000

I've been hearing the word "harness" thrown around a lot lately. I assumed it just meant "the IDE" or "whatever app is running your agent." Turns out, it goes a little deeper than that.

So I sat down with @greggyb and asked him to explain it from the ground up: what an LLM actually does, what turns it into an agent, and where the harness fits into all of it.

What's in the video

Simon Willison's definition of an agent: an LLM with tools, running in a loop to accomplish a goal
What "tools" really means under the hood, and how function calling lets an LLM pull in context it wasn't trained on
The loop part: how an agent programmatically checks its own output to decide if it's actually done
Why the harness is everything after the LLM, and why that's a different thing than the interface
Why you can swap interfaces without touching the underlying harness, and why some agents don't need a UI at all

The point that stuck with me is the harness isn't the app you're looking at. It's the invisible plumbing deciding whether the agent keeps going or calls it done.

Did your mental model of "harness" match up? Or were you picturing something else too?

DEV Community: Google AI

Behind the scenes: How we build, test, and scale Google Agent Skills

How it started: The Next'26 kickoff swarm

The challenge: Scaling without losing quality

The anatomy of an Agent Skill

Architectural best practice: Prefer remote MCP tools

Public export

Automated checks on check-in

Example GitHub Action for skill linting

Continuous evals (on submit & weekly)

Skills are products, not snippets

Supporting authors: Tools and agentic workflows

Internal efficiency with "DevRel Skills"

Wrap-up and over to you

Links and further reading

What's next?

Skills vs MCP: How AI tools have evolved

What's in the video

7 Times Faster and Cheaper? Gemini 3.5 Flash Lite and Gemini 3.6 Flash in Google Cloud Databases

Cloud SQL

AlloyDB

Gemini 3.5 Flash Lite

Summary

AI builder essentials: tokens, context windows and RAG 101

What's in the video

Claude Opus 5 is Live on Agent Platform 🚀

Investing in multi-agent AI safety research

Scaling AI Safety Research for a Multi-Agent World

Why the agent ecosystem matters

Scaling the frontier of multi-agent safety research

A collaborative call to action

How to participate

Google Cloud Skills Tutorial — Part 2 : Intermediate Skills in Action

Prerequisites: Manual Setup

Confirming Skill Installation

Prompt-Driven Authentication Checks

BigQuery Skills

Confirming Skill Installation

Prompt-Driven BigQuery Operations

Cloud Run Deployment

Confirming Skill Installation

Prompt-Driven Application Deployment

To summarize

Google Cloud Skills Tutorial: The Complete Guide to AI-Powered Cloud Operations

What Are Google Cloud Skills?

The google/skills Repository

How Skills Work: The Progressive Disclosure Model

Getting Started

Prerequisites

Installing Skills

Understanding Skill Anatomy

Your First Interaction

Example Prompts to Try

The Series goes on

Gemini 3.6 Flash & 3.5 Flash-Lite: Developer guide

New models

Quickstart

What's new in Gemini 3.6 Flash

What's new in Gemini 3.5 Flash-Lite

Choosing the right Flash or Flash-Lite model

Updated Antigravity agent

API changes and parameter updates

1. Sampling parameter deprecation (temperature, top_p, top_k)

2. Prefilled model turn validation {:#prefilled-model-turn-validation}

⚠️ Avoid

✅ Recommended Migration (Interactions API)

Migration checklist

Migrate to gemini-3.6-flash

Migrate to gemini-3.5-flash-lite

Next steps

Why AI Apps Fail in Production (And How Google Solved It)

The Speed-vs-Risk Paradox

Enter YouTube’s AI Prototyping Stack

Embrace Throw-Away Code

Moving Fast Without Breaking Things

Google Cloud Labs: Accelerate AI with Cloud Run

Moving Beyond the Prototype

The Coffee Shop Journey: A Hands-On Experience

Production-Grade AI on Cloud Run

Ready to Build for Scale? Join us in North America

1. Sampling parameter deprecation (`temperature`, `top_p`, `top_k`)