DEV Community: Google AI

From Dashboards to Autonomous Action: Why You Need to Attend Google Cloud Labs

Joey Lynne Hernandez — Mon, 08 Jun 2026 19:43:35 +0000

The era of passive data analytics is over. Today, the most forward-thinking data teams aren't just building dashboards to show what happened yesterday—they are building the foundational platforms that power applied, Agentic AI.

But bridging the gap between traditional data engineering and the new frontier of agentic workflows isn't something you can learn just by reading whitepapers. You need to get your hands on the tools.

That’s exactly why we’re hitting the road with the Google Cloud Labs: Data Cloud series, coming to Toronto and Chicago this month.

Not Your Average Lecture Series

This isn't a day of sitting back and watching slides. It’s an immersive, hands-on workshop where you’ll spend the day alongside Google engineers building real solutions.

Whether you’re a Data Engineer, Data Scientist, or Data Analyst, this lab is designed to give you the practical skills and architectural patterns needed to make your enterprise data AI-ready. We’ll be diving deep into the actual implementation of Google Cloud’s latest data and AI services.

What You Will Build

Bring your laptop, because throughout the day, you will be working through a series of live labs to build out a complete, agentic workflow powered by your data. Here is a sneak peek at what’s on the agenda:

Mastering Governed Data Ingestion: You'll build unified, governed data pipelines across multi-cloud sources using Spark and Knowledge Catalog.
Unlocking Multimodal Analytics: We’ll move beyond text and numbers, using Gemini in BigQuery to extract insights from unstructured and multimodal data.
Scaling Vector Search: You’ll get hands-on with AlloyDB, learning how to scale vectorized search for high-performance, context-aware AI applications.
Engineering Agentic Workflows: Finally, we’ll bring all these pieces together. Using BigQuery Graph and the Agent Development Kit (ADK), you will build autonomous, agentic workflows that can actually take action based on your data.

Secure Your Spot

Space for these in-person labs is strictly limited to ensure everyone gets dedicated time with our engineers and hands-on support during the exercises.

If you have a strong data foundation and are ready to dive deeper into applied AI, register today:

Toronto: Register for the Toronto Lab (June 25th at the Delta Hotels Toronto)
Chicago: Register for the Chicago Lab (June 30th at the Google Chicago Office)

Introducing Gemma 4 12B: a unified, encoder-free multimodal model

Olivier Lacombe — Fri, 05 Jun 2026 16:51:47 +0000

Gemma 4 12B is designed to bring high-performance multimodal intelligence directly to your laptop, combining mobile-first efficiency with advanced reasoning.

Today, we are introducing Gemma 4 12B, our latest model designed to bring agentic multimodal intelligence directly to laptops. Bridging the gap between our edge-friendly E4B and our more advanced 26B Mixture of Experts (MoE), Gemma 4 12B packages powerful capabilities inside a reduced memory footprint. It is also our first mid-sized model to feature native audio inputs.

Thanks to the developer community, Gemma 4 models have now crossed 150 million downloads. You've built everything from wearable robotic arms for physical assistance to enterprise-grade AI security. We're excited to see what you build with this latest addition.

Here's an overview of what makes Gemma 4 12B unique:

Novel unified architecture: No multimodal encoders. The vision and audio inputs flow directly into the LLM backbone.
Advanced reasoning: Benchmark performance nearing our 26B model, unlocking powerful multi-step reasoning and agentic workflows.
Laptop ready: Small enough to run locally with just 16GB of VRAM or unified memory.
Open and accessible: Released under an Apache 2.0 license with support across the developer ecosystem.
Drafter-ready: Gemma 4 12B comes equipped with Multi-Token Prediction (MTP) drafters to reduce latency.

Together, these features bring advanced multimodal capabilities to everyday hardware without sacrificing speed or reasoning. Let's now take a closer look at how Gemma 4 12B achieves this.

Run state-of-the-art agents locally

Gemma 4 12B delivers performance nearing our larger 26B MoE model on standard benchmarks, but at less than half the total memory footprint. Small enough to run locally on consumer laptops with 16GB of RAM, it unlocks powerful multimodal and agentic experiences right on your machine.

Experience a uniquely efficient, unified architecture

What makes Gemma 4 12B stand out is its streamlined approach to processing visual and audio inputs. Traditional multimodal models typically rely on separate encoders to translate images and audio before passing those representations to the language model. Because these split encoders add latency and increase memory usage, we trained Gemma 4 12B with an encoder-free architecture to integrate audio and vision input directly.

Here is how Gemma 4 12B processes multimodal inputs natively:

Vision: We replaced Gemma 4's vision encoder with a lightweight embedding module consisting of a single matrix multiplication, positional embedding and normalizations. This allows the LLM backbone to take over visual processing.
Audio: We simplified audio processing even further. We removed the audio encoder entirely and projected the raw audio signal into the same dimensional space as text tokens.

For developers who want a breakdown, head over to our companion Gemma 4 12B Developer Guide.

See native audio processing in action: Watch Gemma 4 12B transcribe, format, and translate voice inputs entirely offline using the Google AI Edge Eloquent app.

Get started today

Try it yourself: Experiment with a couple of clicks in LM Studio, Ollama, Google AI Edge Gallery App, the Google AI Edge Eloquent app and the LiteRT-LM CLI
Download the weights: Download the pre-trained and instruction-tuned checkpoints directly from Hugging Face and Kaggle.
Integrate & learn: Review the developer documentation and the quick start notebook.
Use your favorite development tools: Implement local inference pipelines with Hugging Face Transformers, llama.cpp, MLX, SGLang, and vLLM, or fine-tune with efficiency using Unsloth.
Unlock Agentic Development with Gemma Skills: To support agents to build with the latest Gemma advancements, we are releasing our official Skills Repository. This is a library of skills designed specifically to enable agents to build with Gemma models.
Deploy your way: Spin up endpoints in production using Google Cloud. Deploy your way through Gemini Enterprise Agent Platform Model Garden, Cloud Run and GKE.

Kaggle is making AI benchmark creation effortless

Nicholas Kang (Nick) — Thu, 04 Jun 2026 15:51:23 +0000

As AI models evolve from simple chatbots into reasoning agents that write code, use tools and solve complex problems, traditional benchmarks are no longer enough. The community needs dynamic, rigorous evaluations — built by the people who use these models in the real-world.

That’s why we launched Kaggle Benchmarks. Since then, the global AI community has created more than 10,000 evaluation tasks, creating the trustworthy, transparent public leaderboards that help labs measure and accelerate AI progress.

Today, we are taking the next step by launching local development for Kaggle Benchmarks.

Use Kaggle Benchmarks from your local development environment

Until now, creating evaluation tasks meant working exclusively in Kaggle's web-based notebook editor, instead of developers’ preferred stack to build with.

Our new update enables developers to create, validate, push, run and download tasks directly from their local development environments like Antigravity, VSCode, Cursor and coding agents. This update is designed to meet developers where they work, making the journey from idea to evaluation faster and more intuitive.

Build evaluation tasks in natural language with AI coding agents

Local development also unlocks a powerful new workflow: using AI coding agents to write benchmark tasks through the write-kaggle-benchmarks skill. This skill comprises a set of structured instructions that teaches a coding agent how to build tasks using the kaggle-benchmarks SDK and the Kaggle CLI.

To add this skill to your agent, simply ask your agent to:

“Install the write-kaggle-benchmarks skill: https://github.com/Kaggle/kaggle-skills”

Once installed, you can describe an evaluation in plain language and get a working task on Kaggle. For example, you can tell your agent:

Using the write-kaggle-benchmarks skill, build a task that asks the model if "300+140=460 is correct?"

These powerful capabilities are driven by the new commands that we have built for Benchmarks in the Kaggle CLI.

Understand why community-driven evaluations matter

We built Kaggle Benchmarks to democratize trustworthy AI evaluations. We believe that if a capability can be measured, labs will race to improve it. By providing these clear, objective signals, our hope is to empower AI labs to drive model improvements in the areas that matter most.

For AI to truly benefit humanity, evaluations must reflect the full diversity of real-world challenges. We believe this launch is a significant step toward enabling anyone, anywhere, to build the evaluations that will shape the future of AI.

Ready to build? Try Kaggle Benchmarks today.

Additional resources

Read the docs for kaggle-cli on GitHub
Install the write-kaggle-benchmark skill
🎁 Idea → eval? Show us. Post your task + workflow by tagging @kaggle on X or LinkedIn by July 1st for a chance to win Kaggle swag and a social shoutout
Watch the product demo on YouTube

Agent Factory Recap: Building with Gemini 3, AI Studio, Antigravity, and Nano Banana

Amit Maraj — Thu, 04 Jun 2026 13:04:00 +0000

Welcome back to The Agent Factory! This week, we went beyond the hype to dissect the technical details of Google's massive wave of AI releases. We were joined by Paige Bailey, the UTL for Developer Relations at DeepMind, to break down everything from the new Gemini 3 model to the Antigravity IDE.

Google has been shipping at a breakneck pace—literally a new model or feature nearly every day—and this episode is all about how developers can harness these tools right now.

This post guides you through the key ideas from our conversation. Use it to quickly recap topics or dive deeper into specific segments with links and timestamps.

The Tech Stack - What is it?

We tossed around a few new names in this episode. Here is a quick primer on the tech discussed:

Gemini 3: The latest iteration of Google's model family. While Gemini 1 was about understanding and Gemini 2 was about reasoning, Gemini 3 is designed for acting and coding. It features improved tool use and function calling.
Antigravity: Google's new AI-native IDE (Integrated Development Environment) designed to integrate Gemini 3 directly into the coding workflow, allowing for multimodal inputs like screenshots to drive code changes.
Nano Banana Pro: The newest iteration in the media generation series, capable of creating high-fidelity images, voxel art, and game assets.

The Factory Floor

The Factory Floor is our segment for getting hands-on. Here, we moved from high-level concepts to practical code with live demos.

Building "Nordic Shield" with Gemini 3

Timestamp: 11:20

Paige demonstrated the "Build" feature in AI Studio to create a complex React application from scratch. The goal was to test the model's ability to self-correct and handle specific design constraints.

The Prompt: Create an insurance cataloging app using the webcam and microphone. It needed a "Nordic/IKEA" design theme, an inventory list, and the ability to estimate item value using Google Search grounding.
The Process: Gemini 3 generated a React Native app, set up the directory structure, and wrote its own prompts for the agents.
The Result: The app, named "Nordic Shield," successfully cataloged items (like a Pixel 7 and a soda can) via video. When it encountered audio issues, it generated a reasoning trace to debug the problem live. It successfully utilized Gemini Live for the conversation and executed a secondary "agentic" step to search Google for the estimated value of the items.

Redesigning a Website with Antigravity

Timestamp: 30:27

We shifted gears to look at Google's new IDE, Antigravity. The goal was to update an existing, text-heavy website to match a new, vibrant "neo-brutalist" design aesthetic using only screenshots as a guide.

The Input: The existing codebase plus two screenshots of the desired visual style (doodly, pastel, notebook-esque).
The Implementation: Antigravity analyzed the images to understand the design philosophy. It created a task list and an implementation plan to ensure it stayed grounded.
The Outcome: The IDE successfully refactored the site to match the brand guidelines, introducing "jiggling pill" UI elements and updating the color palette to match the provided screenshots perfectly.

Paige Bailey on The Evolution of Gemini

We sat down with Paige to understand how DeepMind is approaching the rapid evolution of their models and what it means for developers building agents today.

The Three Stages of Gemini

Timestamp: 2:49

Paige outlined the clear evolutionary path of the Gemini family. She explained that the original Gemini was focused on multimodal understanding (video, text, audio). Gemini 2 introduced thinking—the ability to reason and plan step-by-step. Gemini 3, the current iteration, is all about acting. This model is optimized for acting on its reasoning, specifically through coding and tool use, allowing for composite architectures where models work together rather than in isolation.

Pre-Training vs. Post-Training

Timestamp: 4:55

We discussed the "schooling" of these models. Paige used a great analogy:

Pre-training is like sending the model to school. It involves giving Gemini access to massive amounts of tokens (internet data, synthetic data, video game footage) to learn the basics.
Post-training is "on-the-job experience." This is where DeepMind provides specific, hand-curated examples of complex workflows, such as multi-turn conversations that involve editing websites or using multiple tools to accomplish a single task.

The "Vending Bench"

Timestamp: 6:48

Benchmarks are changing. Paige introduced us to a fascinating new evaluation metric called Vending Bench. This test gauges a model's ability to run a passive business—specifically, a vending machine. The model must figure out stock, reorder items, deploy restockers, and do long-range planning to maximize uptime. The score is determined by how much profit the model generates in a year. Currently, Gemini 3 Pro is generating around $5,462 per machine, showing significant improvements in long-term strategic decision-making.

Creative Multimodality with Nano Banana

Timestamp: 28:34

We also touched on the creative side of the stack. Paige highlighted that when you combine reasoning with multimodal outputs, the possibilities explode. She shared examples of Nano Banana Pro being used to generate game assets, orthographic blueprints for 3D modeling (like castles), and detailed physics explainers. The key takeaway is the power of combining these media models with search grounding to create accurate, high-fidelity visual assets.

Conclusion

It is incredible to see not just the models, but the entire ecosystem Google is building—from the hardware to the IDEs like Antigravity. The ability to deploy these agents directly to Google Cloud with a single click bridges the gap between a cool demo and a production-ready application.

As Paige mentioned, the trajectory is exponential. Whether you are building passive businesses or complex coding agents, the tools are ready.

Your turn to build

If you haven't yet, head over to AI Studio or try out the Gemini API.

Try the "Vending Bench" challenge yourself—can you build an agent that runs a better business than Gemini 3?

Let us know what you build!

Connect with us

Amit Maraj → LinkedIn, X, TikTok
Paige Bailey → LinkedIn, X

The Ultimate Cloud Run Guide 2026

Sara Ford — Mon, 01 Jun 2026 14:31:53 +0000

At Cloud Next '26, my teammate Wietse and I gave a talk called the Ultimate Guide to Cloud Run. We wanted to provide a comprehensive walkthrough of Cloud Run to experienced developers who know how to ship software, but might be new to Cloud Run.

This post recaps the Cloud Run fundamentals we went over in our talk. Each segment below has a link to the timestamp in the talk along with examples for you to try at home.

Getting started - deploy a container
Autoscaling / audience participation demo
How gcloud Works Under the Hood
Overview of Cloud Run resources
Reliable Rollouts and Preview Links
Structured Logging
Troubleshooting: "container failed to start on port 8080"
Google Cloud Developer Knowledge MCP server
How to avoid hard-coded API Keys
Ephemeral Disks
Volume mounts
VPC Networking
Two Pricing Models
Scale-to-zero GPUs
Deploying an ADK agent

Prefer to watch the full talk instead? You can watch it here.

1. Getting started - deploy a container

Where to watch:

Demo 1 (Nginx) at 1:04

Code examples:

Recap:

Cloud Run is Google Cloud's serverless engine. With Cloud Run you can run any container, on demand, without any infrastructure management. No VMs or clusters to manage.

Hello Cloud Run!

Below is the sample hello container running on Cloud Run.

Don't have a container? It's all good! You can deploy from your source code. See section 3 - How gcloud Works Under the Hood

2. Autoscaling / audience participation demo

Where to watch:

Demo 2 watch at 6:10 Each audience member who scans the QR code gets their own container

Discussion:

Discussion from talk at 28:13

Docs:

Instance Autoscaling

Recap:

Minimum Instances: You can configure minimum instances to keep containers pre-warmed, eliminating "cold start" latency.
Maximum Instances: Set a hard limit on scaling to act as a budget safeguard and protect backend databases from being overwhelmed.

3. How gcloud Works Under the Hood

Where to watch

Demo 3 at 9:54

Code examples:

Quickstart: Build and deploy a Go web app to Cloud Run (or one of the other buildpack-supported languages)
deploy from source example from talk

Recap: When you type the simple command gcloud run deploy to deploy from source, gcloud performs the following steps for you:

Upload: Your local directory is safely uploaded to a secure Google Cloud Storage (GCS) bucket.
Build: Cloud Build takes over. If you have a Dockerfile, it runs a docker build. If not, it uses open-source Buildpacks to automatically detect your language and compile a container image.
Store: The completed container image is pushed to Artifact Registry.
Create: Cloud Run spins up a new Revision (a read-only, immutable copy of your container and its settings).
Migrate: Once the new revision passes its startup probe (confirming it is healthy), Cloud Run seamlessly migrates 100% of web traffic over to it.

But what about other resources besides services...

4. Overview of Cloud Run resources

Where to watch

Discussion in talk at 3:38

Code examples:

Recap:

Services:
- Purpose: Best for web applications, APIs, and microservices.
- Features: Automatically scales instances up or down based on incoming traffic. Includes out-of-the-box HTTPS, traffic splitting, and support for WebSockets, gRPC, and HTTP/2.
Jobs:
- Purpose: Best for tasks that run to completion and do not require an active web endpoint.
- Features: Runs for up to 7 days. Excellent for data processing, database migrations, or night-run scripts. You can parallelize a large job into multiple concurrent tasks.
- more Jobs codelab examples
Worker Pools:
- Purpose: Best for continuous background tasks.
- Features: Always-on instances that actively pull for work (e.g., listening to a message queue). Scaling is handled manually.
- more Worker Pools codelab examples
Functions:
- Purpose: Best for single-purpose pieces of code (e.g., responding to a file upload event).
- Features: Supports popular runtimes like Python, Node.js, Go, and Java. No Dockerfile is required; Google automatically builds the container for you from source.
- more Functions codelab examples

5. Reliable Rollouts and Preview Links

Where to watch

Code example:

gradual rollouts and preview links codelab

Recap: Cloud Run versioning relies on immutable revisions:

Zero-Downtime Updates: The new version scales up fully before traffic begins migrating over.
Rollbacks: If a bug gets into production, you can rollback traffic to any healthy, previous revision.
Preview Links (Traffic Tags):
- Instead of auto-deploying to the public, you can pin production traffic to your stable revision
- Apply a "traffic tag" to your latest test revision
- This generates a private preview URL (e.g., https://latest---[your-service].run.app) where you can test changes.

6. Structured Logging

Where to watch

Discussion in talk at 14:58

Recap:

No logging libraries required: To log, simply write standard text directly to stdout or stderr.
Use Structured Logging: Write your logs in JSON format. This allows you to easily run queries in Cloud Logging for custom fields (such as jsonPayload.user_id = "12345").

7. Troubleshooting container failed to start on port 8080

Where to watch

Discussion in talk: 15:28

Code example:

Deploy hello container but set port to 8081 🙂

Recap:

How to troubleshoot the "The container failed to start on port 8080" error:
- This means that Cloud Run couldn't start the container. This could be for many reasons.
- First scroll up in the logs to search for startup code crashes.
- Verify your code is actually listening on the port designated by the PORT environment variable.
- If your app loads large machine learning models, move database connections or loading actions out of the immediate container startup scope to prevent timeouts.

8. Google Cloud Developer Knowledge MCP server (in public preview)

Where to watch

Discussion at 19:58

Example:

Codelab for Developer Knowledge MCP server

Recap:

Great for keeping your agent up to date past its data training date.

Looking for other MCP use cases?

use the Cloud Run MCP server to deploy your apps
host your own MCP server on Cloud Run
- How to deploy a secure MCP server on Cloud Run | Google Codelabs
- Build and deploy an ADK agent that uses an MCP server on Cloud Run | Google Codelabs

9. How to avoid hard-coded API Keys

Where to watch

Code examples:

blog post on local development and ADC (works the same for Cloud Run)
How to upload and serve images using Cloud Storage, Firestore and Cloud Run | Google Codelabs
how to use secret manager

Recap:

Application Default Credentials (ADC): Google client libraries automatically search for local credentials to handle authentication to Google's APIs for you.
Cloud Run Identity: Assign a dedicated Service Account to your Cloud Run service. The client libraries will automatically request credentials from the metadata server to access APIs (like Firestore or Gemini).
Localhost Development: Run gcloud auth login application-default on your machine. Local client libraries will securely use your personal developer identity (e.g. gcloud auth list) or use --impersonate-service-account <service-account>
Secret manager: For when you absolutely need to save keys. Store database passwords or third-party API keys securely. You can mount them into Cloud Run directly as environment variables or volume mounts (or use the secret manager client library)

10. Ephemeral Disks

Where to watch

Discussion in talk: 28:02

Code example:

Configure an ephemeral disk for Cloud Run services

Recap:

Ephemeral Disks: Local, high-speed temporary storage. It lives and dies with the container instance and allows you to process large scratch files without consuming your system's active RAM memory.

11. Volume mounts

Where to watch

Discussion in talk: 27:42

Code example:

Configure Cloud Storage volume mounts for Cloud Run services | Google Cloud Documentation

Recap:

Cloud Storage Volume Mounts: Mount a Cloud Storage bucket or an NFS network file system directly as if it were a local directory.

12. VPC Networking

Where to watch

Discussion & Demo in talk: 29:04

Code example:

VPC networking codelab

Recap:

Direct VPC Egress: Send outbound traffic directly into your internal Google Cloud VPC network. No Serverless VPC Access connector required.
Secure Private Backends: You have two options:
- Option 1 (IAM Authentication): Require authentication and grant the run.invoker role to your frontend's service account.
- Option 2 (VPC Routing): Configure your backend to exclusively accept traffic originating from your VPC network.

13. Two Pricing Models

Where to watch

Discussion in talk: 33:14

Recap:

Cloud Run offers two pricing models so you can optimize your spending.

Request-based pricing (default)
- Pay for container instance time (CPU and memory)
- No charge for idle instances (instances that are not handling requests)
- CPU is slowed down during idle
- There's a fee per request
- Minimum instances are charged a lot* less than the full rate when idle
Instance-based pricing
- Pay for container instance time (CPU and memory), also when idle
- Idle instances and minimum instances are charged at full rate
- Idle instances shut down after a maximum of 15 minutes
- No per-request fee
- Pay less* for instance time when compared with request-based pricing

* See Cloud Run Pricing docs page for more details

Note: Cloud Run continuously analyzes your actual traffic patterns and will automatically recommend switching to Instance-based if it will save you money.

14. Scale-to-Zero GPUs

Where to watch

Discussion in talk: 35:18

Code examples:

getting started GPUs

Recap:

Cloud Run fully supports scale-to-zero GPUs.
Access NVIDIA L4 and the NVIDIA RTX PRO 6000 Blackwell chips
Used for fine-tuning models via Cloud Run Jobs, or hosting lightweight open-source models like Google's Gemma.

15. Deploying an ADK agent

A Warm Welcome to "gemma-skills"

bebechien — Fri, 29 May 2026 21:52:03 +0000

Gemma, a family of open models, are lightweight, remarkably capable, and have a wonderful "tunability" that makes them perfect for personal projects and enterprise-grade applications alike. But as the ecosystem grew, I found myself asking the same questions over and over:

Which exact model size fits my constraint?
How do I build an application powered by Gemma that does XYZ?
How to deploy a Gemma model to production on Google Cloud for my team to use?

To solve this, we put together a living repository called gemma-skills (which we're releasing!). It's a curated, structured collection of developer skills designed to help both humans and agentic AI assistants build beautiful applications with Gemma models without the friction.

Let's take a walk through what's inside!

The Heart of the Repo: `gemma-dev`

At the center of the repository is our first major skill: gemma-dev. It's a skill file (SKILL.md) that serves as a blueprint. It's designed for agents to find what are the latest capabilities, model sizes, good practices, and resources to build with Gemma.

Keeping Pace with Rapid Ecosystem Evolution

The Gemma ecosystem moves fast, with new models, libraries, and best practices emerging constantly. For developers using foundational LLMs like Gemini, keeping assistant workflows perfectly synced with these rapid releases is a common challenge. Because foundational models are trained on vast, fixed datasets, they don't automatically inherit the day-one nuances of a rapidly evolving framework. This can manifest in a few typical development scenarios:

Navigating Version Transitions: General-purpose assistants may default to established standards (like Gemma 2 or 3) even when your project is ready to leverage the latest capabilities of Gemma 4.
Aligning with Modern Libraries: Recommendations might occasionally lean toward older API patterns rather than the latest optimized packages.
Integrating Next-Gen Features: Cutting-edge implementation details (e.g. Multi-Token Prediction (MTP) or specialized formatting) require specialized context to execute flawlessly.

The gemma-skills repository bridges this gap. By providing "live" best practices and structured skill documents directly into your development workflow, we ensure your AI assistant has immediate access to the most current, efficient, and reliable implementation patterns available today.

How to Use This Repo with Antigravity

These skills are designed to be entirely harness-agnostic. They integrates into any developer workflow or agentic tool, from Gemini to Claude. To get started quickly, whether you're leveraging these as clean templates or equipping an AI assistant, the Antigravity CLI (agy) is available as a straightforward way to interact with the repository.

Install gemma-dev skill: Copy gemma-dev folder to your agent skill folder.
Start Your Session: Launch an interactive Antigravity session by running agy in your terminal. From there, you can query the agent in plain English regarding the Gemma ecosystem. Since agy leverages the gemma-dev skill, you'll receive the most precise and up-to-date technical guidance available.
Build Something Wonderful: With your infrastructure handled autonomously, you can focus on the creative work. Turn on your favorite music, brew a fresh cup of coffee, and start creating!

Building with Gemma Skills

Example Prompt: Build a smart home simulator using Gradio and Gemma, use direct voice input to Gemma to minimize the latency for controlling the home.

Keep in mind that while the demo is functional, running a full-precision model via transformers can feel a little sluggish. For a better experience and optimal performance, I typically suggest serving a quantized version through a backend like Ollama or LM Studio, as shown in this next example.

Example Prompt: Build a terminal app that translates a user's natural language input into an ascii art animation, using Gemma and LM Studio backend.

I invite you to dive deeper into the vast world of Gemma and its surrounding ecosystem. You'll surely discover it's an incredibly rewarding journey.

Thank you for reading. If you build something cool with gemma-skills, let me know! Happy building!

In 2026, you can just prompt your way to a working Android app. 🤯

Paige Bailey — Thu, 28 May 2026 15:56:02 +0000

If you’ve been doing Android development for a while, you know the drill. You start a new project, wait for Gradle to sync (and maybe grab a coffee ☕), set up your architecture, write out your ViewModels, configure your Navigation graph, and finally start building your Jetpack Compose screens.

It’s a labor of love, but the initial boilerplate (and knowing which libraries to use!) can be a grind.

With the recent announcement of prompt-to-Android-app generation in Google AI Studio, the barrier to entry for building Android apps just got completely demolished. Here is what you need to know about the new update, how it works, and what it actually means for us as developers.

What is "Prompt-to-Android-App"?

In a nutshell, Google has integrated native Android project generation directly into AI Studio. Instead of writing code line-by-line to scaffold your app, you describe what you want in plain English.

AI Studio then spits out a fully structured, compilation-ready Android Studio project using modern Android development (MAD) standards. We're talking:

100% Kotlin
Jetpack Compose for the UI
Recommended MVVM architecture right out of the box
Material Design 3 theming applied
Potential to connect to other Google services, like Workspace and Firebase

How it looks in practice

Imagine you have an idea for a simple habit-tracking app. Instead of spending hours setting up the foundation, you can feed AI Studio a prompt like this:

"Create a 3-screen Android app for tracking daily habits. Screen 1 is a dashboard showing today's habits with checkboxes. Screen 2 is a form to add a new habit with a name, frequency, and icon. Screen 3 is a settings page. Style it with a dark purple theme."

Within seconds, AI Studio generates the complete app, including design and rendering via an Android emulator.

Final thoughts

This is a massive win for productivity. It lowers the barrier for beginners to see immediate results, and it allows experienced devs to bypass the tedious setup phase and jump straight into solving the actual, interesting problems. We've already seen many folks who have never built mobile apps before get a first deployment out into the world!

Have you tried generating an app in AI Studio yet? Let me know your experiences in the comments below! 👇

How I built a supersonic AI riddling duel in under 20 Minutes (with zero manual coding)

Remigiusz Samborski — Thu, 28 May 2026 14:54:55 +0000

Can an AI developer agent build complex full-stack logic without constant hand-holding?

To test this, I set up the #NapkinChallenge: take a rough architectural sketch on a paper napkin and turn it into a fully functional web application in under 20 minutes.

The goal: Build "Blaine the Mono's Riddling Competition" — a game where you duel a psychotic, sentient supersonic monorail from Stephen King's The Dark Tower series. If you trip him up with three logic-defying riddles, you save the passengers. If his neural net solves them, you crash at Mach 4.

The result? The AI built the entire application with zero manual lines of code written by me.

Here is how the architecture works, how the backend uses the new @google/genai SDK, and how you can run the challenge yourself.

The Architecture (from sketch to code)

The napkin sketch outlined a straightforward but highly interactive setup:

Frontend: A UI built in Next.js (App Router).
Backend: A Next.js API route that forwards user riddles to the Gemini API.
The Engine: The gemini-3-flash-preview model, prompted to act as Blaine the Mono. It must analyze the riddle and return structured JSON containing its solution, status, and theatrical psychotic commentary.

Key Takeaways

Zero-Code Feasibility: Developer agents like Antigravity can now understand visual layouts, bootstrap templates, design customized styling systems, and integrate real-world API clients with robust error boundaries.
Styling is a First-Class Citizen: The agent did not just generate functional code; it constructed a bespoke styling sheet (src/app/globals.css) incorporating Orbitron typography, custom CSS scrollbars, CRT overlays, and reactive screen shakes using CSS keyframes.
Time to Gameplay: The entire application was built in under 20 minutes, including the time it took to generate the code, test it, and get it running.

Video

See the full video of the process:

Join the #NapkinChallenge 📝

Now it is your turn. Can you match the speed of autonomous generation?

Sketch your app concept, system architecture, or database model on a physical paper napkin.
Upload the photo to Antigravity, Gemini, or Google AI Studio.
Prompt your agent to build the code from the image alone.
Share a video or screenshot of your live app using #NapkinChallenge!

Let's see what you can build!

Can Google Antigravity 2.0 Pass the "Napkin Challenge"? 📝🚀

Shir Meir Lador — Wed, 27 May 2026 00:02:51 +0000

🚀 From Napkin Sketch to data-driven real-estate advisor Agent in Under 40 Minutes? 🚀

Can a coding agent really work autonomously on complicated problems without human intervention? I decided to put Google’s new Antigravity 2.0 and Gemini 3.5 to the test: The Napkin Challenge. 📝

The goal: Build and deploy a real estate investment advisor - based on real-world data, starting with nothing but a rough sketch on a napkin.

The Result? With the right context, yes!

I used:
Antigravity 2.0 & Gemini 3.5: Architect and execute the plan
Agent CLI Skills: Scaffold, build, test and evaluate the agent using ADK.3
Developer Knowledge MCP: Provided necessary context to connect to BigQuery MCP and integrate the census dataset for grounded investment advice.
Parallelized Workflow using sub-agents: While the system ran the evaluation suite, it simultaneously deployed the agent to Cloud Run.

The Outcome:

Built and deployed in under 40 minutes.
Zero human input beyond a napkin sketch (other than approving the plan and setting the model and region).
100% passing scores on evaluation cases, with responses delivered in under 30 seconds.
A fully functional real estate advisor providing data-driven analysis on short and long term investments.

The "Napkin Challenge" proves that when you combine the right context with powerful models, the barrier between an idea and a deployed product has virtually disappeared.

I challenge you: What is your "napkin" project? Try it with Antigravity 2.0 and Gemini 3.5. 📝

🚀 How to join the challenge -

Sketch an architecture or app idea on a literal napkin.
Feed it to Antigravity 2.0 + Gemini 3.5. (I recommend making sure you have relevant skills in place for the task - context makes all the difference!)
Drop a quick video or screenshot of your results on socials with the hashtag #NapkinChallenge.
Add the link to your demo in the comments to this post!
Tag 3 other folks and give them 48 hours to match the challenge! 👇 What will you build? Let me know in the comments!

From Code to Cloud: 3 Labs for Deploying Your AI Agent

Shir Meir Lador — Thu, 21 May 2026 15:49:59 +0000

You've built a powerful AI agent. It works on your local machine, it's intelligent, and it's ready to meet the world. Now, how do you take this agent from a script on your laptop to a secure, scalable, and reliable application in production? On Google Cloud, there are multiple paths to deployment, each offering a different developer experience.

If you are looking for a detailed architectural comparison to help you choose between Cloud Run, Google Kubernetes Engine (GKE), and Vertex AI Agent Engine, you can start by reading Choosing the Right Deployment Path for Your Google ADK Agents.

Ready to build? As part of our Production-Ready AI on Google Cloud Learning Path, we've created three distinct hands-on labs to help you experience these deployment options for yourself.

The Managed Solution: Vertex AI Agent Engine

For teams seeking the simplest path to production, Vertex AI Agent Engine removes the need to manage web servers or containers entirely. It provides an opinionated environment optimized for python agents, where you define the agent's logic, and the platform handles the execution, memory, and tool invocation.

Start the lab!
Lab: Create multi agent system with ADK, deploy in Agent Engine and get started with A2A protocol

Objective: Deploy a multi-agent system without provisioning any infrastructure, leveraging built-in capabilities for state management and reasoning while Google manages the runtime.

The Serverless Experience: Cloud Run

For teams that want the flexibility of containers without the operational overhead, Cloud Run abstracts away the infrastructure, allowing you to deploy your agent as a container that automatically scales up when busy and down to zero when quiet.

This path is particularly powerful if you need to build in languages other than Python, use custom frameworks, or integrate your agent into existing declarative CI/CD pipelines.

Start the lab!
Lab: Build and deploy an ADK agent on Cloud Run

Objective: Containerize a tool-using agent with the Google Cloud ADK and deploy it to a secure public HTTPS endpoint to experience the speed of a serverless workflow.

The Orchestrated Experience: Google Kubernetes Engine (GKE)

For teams that need precise configuration over their environment, GKE is designed to manage that complexity. This path shows you how an AI agent functions not just as a script, but as a microservice within a broader orchestrated cluster.

Start the lab!
Lab: Deploy ADK agents to Google Kubernetes Engine (GKE)

Objective: Deploy an ADK agent into a managed Kubernetes cluster, configuring autoscaling and precise resource limits using industry-standard tooling and manifests.

Your Path to Production

Whether you are looking for serverless speed, orchestrated control, or a fully managed runtime, these labs provide the blueprint to get you there.

These labs are part of the Deploying Agents module in our official Production-Ready AI with Google Cloud program. Explore the full curriculum for more content that will help you bridge the gap from a promising prototype to a production-grade AI application.

Share your progress and connect with others on the journey using the hashtag #ProductionReadyAI. Happy learning!

Scaling Intelligence Workshop: Google NYC, Thursday, May 28th 🚀

Jen Harvey — Tue, 19 May 2026 23:37:00 +0000

Do I just post about cool events? Maybe? But that's good, right? Now here's another!

Scaling Intelligence: Accelerating HPC and Inference Workflows.

If you’re building or scaling Generative AI infrastructure, you already know the stakes. Balancing the massive compute demands of LLMs with strict production latency and data security requirements is a massive architectural hurdle.

Whether you're tackling real-time streaming analytics, automated compliance pipelines, or complex risk modeling, your underlying infrastructure shouldn't be your bottleneck.

On Thursday, May 28th, we’re hosting an exclusive, hands-on workshop at Google NYC (111 8th Ave) designed specifically for engineers, architects, and tech leaders: Scaling Intelligence: Accelerating HPC and Inference Workflows.

🛠️ The Tech Breakdown
This isn't a high-level pitch; we're diving into the actual plumbing required for breakthrough performance:

Next-Gen Compute Architectures: Blueprinting high-throughput infrastructure built to handle concurrent, low-latency inference workloads at scale.
The Hardware & Software Stack: Get a closer look at optimizing workloads using Google Cloud’s new G4 VMs (powered by the massive NVIDIA RTX Pro 6000 Blackwell architecture) alongside TensorRT for maximum throughput.
Hands-on Labs: Bring your laptop. You'll get practical experience deploying and optimizing state-of-the-art open-source models like Gemma and Llama 3, with live guidance from Google Cloud and NVIDIA AI experts.

👥 Bring the Whole Squad
Infrastructure decisions don't happen in a vacuum. To get the most out of the hands-on labs and architecture deep-dives, we highly encourage bringing a cross-functional team (2–4 people) across:

AI/ML Architecture & Engineering
Platform Engineering / DevSecOps
IT & Infrastructure Leadership

Aligning your data scientists with your infrastructure engineers is the fastest way to unblock your production roadmap.

📍** Logistics & Details**
Where: Google NYC (111 8th Ave)

When: Thursday, May 28 | 12:00 PM – 4:00 PM (Stick around for the networking reception right after!)

Note on Availability: Spaces are strictly limited to ensure high-quality, hands-on coaching and meaningful architectural reviews during the labs.

👉 Register your team here to secure your spot

3 takeaways from the IO '26 developer keynote

Tilde A. Thurium — Tue, 19 May 2026 21:53:04 +0000

My top 3 takeaways from the IO 26’ developer keynote, in no particular order:

Gemini 3.5 Flash GA is a breakthrough for developers worldwide. In plain English, this model offers flagship-tier coding brains that run at lightning speeds for a fraction of the cost of frontier models. This is a massive win for international devs, as the ultra-low cost levels the playing field against steep USD exchange rates, and the raw speed easily offsets regional network latency. I tested it out myself by vibe coding a vaporwave-themed pet store app with Antigravity. I was impressed with how snappy the code generation felt.

Google AI Studio new features can make anyone a builder. One-click deployment to Firebase and Cloud Run makes it easier than ever to go from demo to serving real users. Custom asset generation with Nano Banana makes your vibe coded apps look sharp. And when you’re ready to add next-level complexity, now it’s easier than ever to export your project to Antigravity.
Antigravity 2.0 unlocks full-stack agentic development. You can now use always-on agents that build for you while you sleep, while the new Antigravity SDK lets you richly customize your agents and deploy them to private infrastructure.

For more details, check out the official announcement blog and stay tuned for upcoming Dev.To challenges where you can build with our new models. What are you most excited about?