DEV Community: Mollie Pettit

Building Connected Agents with MCP and A2A

Mollie Pettit — Wed, 28 Jan 2026 20:07:34 +0000

To build a production-ready agentic system, where intelligent agents can freely collaborate and act, we need standards and shared protocols for how agents talk to tools and how they talk to each other.

In the Agent Production Patterns module in the Production-Ready AI with Google Cloud Learning Path, we focus on interoperability, exploring the standard patterns for connecting agents to data, tools and each other. Here are three hands-on labs to help you build these skills.

The Foundations of ADK, MCP, A2A

This lab serves as your "Hello World" for the modern agent stack. You will build a simple, specialized agent that demonstrates how Agent Development Kit (ADK), Model Context Protocol (MCP), and Agent to Agent Protocol (A2A) work together.

Start the lab!
Lab: Getting Started with MCP, ADK and A2A

Objective: Build a specialized currency agent that handles exchange rates, demonstrating the core building blocks ADK, MCP, and A2A communication.

Connecting to Data with MCP

Once you understand the basics, the next step is giving your agent access to knowledge. Whether you are analyzing massive datasets or searching operational records, the MCP Toolbox provides a standard way to connect your agent to your databases.

Expose a BigQuery database to an MCP Client

This lab shows you how to expose BigQuery tables to an MCP client.

Start the lab!
Lab: MCP Toolbox for Databases: Making BigQuery datasets available to MCP clients

Objective: Configure the MCP Toolbox to expose a public BigQuery dataset to an AI agent, enabling it to query and analyze datasets using natural language.

Expose a CloudSQL database to an MCP Client

If you need your agent to search for specific records—like flight schedules or hotel inventory—this lab demonstrates how to connect to a CloudSQL relational database.

Start the lab!
Lab: Build a Travel Agent using MCP Toolbox for Databases and Agent Development Kit (ADK)

Objective: Build a full-stack agent that interacts with a Cloud SQL database to search for flights and hotels, demonstrating how to securely expose relational data to an AI agent.

From Prototype to Production

By moving away from custom integrations and adopting standards like MCP and A2A, you can build agents that are easier to maintain and scale. These labs provide the practical patterns you need to connect your agents to your data, your tools, and each other.

These labs are part of the Agent Production Patterns module in our official Production-Ready AI with Google Cloud Learning Path. 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 using the hashtag #ProductionReadyAI. Happy learning!

Agent Factory Recap: Build AI Apps in Minutes with Google's Logan Kilpatrick

Mollie Pettit — Mon, 26 Jan 2026 15:01:57 +0000

In our latest episode of The Agent Factory, we were thrilled to welcome Logan Kilpatrick from Google Deep Mind for a vibe coding session that showcased the tools shaping the future of AI development. Logan, who has had a front-row seat to the generative AI revolution at both OpenAI and now Google, gave us a hands-on tour of the vibe coding experience in Google AI Studio, showing just how fast you can go from an idea to a fully-functional AI application.

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 Build Experience in Google AI Studio - What is it?

This episode focused on the Build feature in Google AI Studio and Logan used the term vibe coding to describe the experience of using it. This feature is designed to radically accelerate how developers create AI-powered apps. The core idea is to move from a natural language prompt of an idea for an app to a live, running application in under a minute. It handles the scaffolding, code generation, and even error correction, allowing you to focus on iterating and refining your idea.

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.

Vibe Coding a Virtual Food Photographer

Timestamp: [01:14]

To kick things off, Logan hit the "I'm Feeling Lucky" button to generate a random app idea: a virtual food photographer for restaurant owners. The goal was to build an app that could:

Accept a simple text-based menu.
Generate realistic, high-end photography for each dish.
Allow for style toggles like "rustic and dark" or "bright and modern."

In about 90 seconds, we had a running web app. Logan fed it a quirky menu of pizza, blueberries, and popcorn, and the app generated images of each. We also saw how you can use AI-suggested features to iteratively adjust the prepared photos—like adding butter to the popcorn, and add functionality—like changing the entire design aesthetic of the site.

Grounding with Google Maps

Timestamp: [10:25]

Next, Logan showcased one of the most exciting new features: grounding with Google Maps. This allows the Gemini models to connect directly to Google Maps to pull in rich, real-time place data without setting up a separate API. He demonstrated a starter template app that acted as a local guide, finding Italian restaurants in Chicago and describing the neighborhood.

Exploring the AI Studio Gallery

Timestamp: [14:55]

For developers looking for inspiration, Logan walked us through the AI Studio Gallery. This is a collection of pre-built, interactive examples that show what the models are capable of. Two highlights were:

Prompt DJ: An app that uses the Lyria model to generate novel, real-time music based on a prompt.
Vibe Check: A fun tool for visually testing and comparing how different models respond to the same prompt, which is becoming a popular way for developers to quickly evaluate a model's suitability for their use case.

"Yap to App": A Conversational Pair Programmer

Timestamp: [19:51]

For the final demo, Logan used a speech-to-text input to describe an app idea which he called "Yap to App". His pitch: an AI pair programmer that could generate HTML code and then vocally coach him on how to improve it. After turning his spoken request into a written prompt, AI Studio built a voice-interactive app. The AI assistant generated a simple HTML card and then, when asked, provided verbal suggestions for improvement.

The Agent Industry Pulse

Timestamp: [26:19]

In this segment, we covered some of the biggest recent launches in the agent ecosystem:

Veo 3.1: Google's new state-of-the-art video generation model that builds on Veo 3, adding richer native audio and the ability to define the first and last frames of a video to generate seamless transitions. Smitha showcased a quick applet, built entirely in AI Studio, where users can upload a selfie of themselves and generate a video of their future career in AI using Veo 3.1.
Anthropic's Skills: A new feature that allows you to give Claude specific tools (like an Excel script) that it can decide to use on its own to complete a task. We compared this to Gemini Gems, noting the difference in approach between creating a persona (Gem) and providing a tool (Skill).
Recent Google Launches: Logan highlighted several other key releases, including the new Gemini computer use model for building agents that can navigate browsers, updates to the Flash and Flash-Lite models, and foundational upgrades to the AI Studio experience itself.

Logan Kilpatrick on the Future of AI Development

We also had the chance to discuss the bigger picture with Logan, from developer reactions to the future of models themselves.

Grounding with Google Maps

Timestamp: [31:26]

When asked which launch developers have been most excited about, Logan admitted he was surprised by the overwhelmingly positive reception for grounding with Google Maps. He noted that the Maps API is one of the most widely used developer APIs in the world, and making it incredibly simple to integrate with Gemini unlocked key use cases for countless developers and startups.

From Models to Systems: The Next Frontier

Timestamp: [32:26]

Looking ahead, Logan shared his excitement for the continued progress on code generation, which he sees as a fundamental accelerant for all other AI capabilities. He also pointed out a trend: models are evolving from simple tools into complex systems.

Historically, a model was something that took a token in and produced a token out. Now, models are starting to look more like agents out of the box. They can take actions: spinning up code sandboxes, pinging APIs, and navigating browsers. "Folks have thought about agents and models as these decoupled concepts," Logan said, "and it feels like they're coming closer and closer together as the model capabilities keep improving."

Conclusion

This conversation was a powerful reminder of how quickly the barrier to entry for building sophisticated AI applications is falling. With tools like Google AI Studio, the ability to turn a creative spark into a working prototype is no longer a matter of weeks or days, but minutes. The focus is shifting from complex scaffolding to rapid, creative iteration.

Your turn to build

We hope this episode inspired you to get hands-on. Head over to Google AI Studio to try out vibe coding for yourself, and don't forget to watch the full episode for all the details.

Connect with us

Logan → LinkedIn, X, BlueSky, blog
Mollie → LinkedIn, X, BlueSky
Smitha → LinkedIn, YouTube, X, Instagram

Production-Ready AI with Google Cloud Learning Path

Mollie Pettit — Tue, 20 Jan 2026 14:51:04 +0000

We're excited to launch the Production-Ready AI with Google Cloud Learning Path, a free series designed to take your AI projects from prototype to production.

This page is the central hub for the curriculum. We'll be updating it weekly with new modules from now through mid-December.

Why We Built This: Bridging the Prototype-to-Production Gap

Generative AI makes it easy to build an impressive prototype. But moving from that proof-of-concept to a secure, scalable, and observable production system is where many projects stall. This is the prototype-to-production gap. It's the challenge of answering hard questions about security, infrastructure, and monitoring for a system that now includes a probabilistic model.

It’s a journey we’ve been on with our own teams at Google Cloud. To solve for this ongoing challenge, we built a comprehensive internal playbook focused on production-grade best practices. After seeing the playbook's success, we knew we had to share it.

This learning path is that playbook, adapted for all developers. The path's curriculum combines the power of Gemini models with production-grade tools like Vertex AI, Google Kubernetes Engine (GKE), and Cloud Run.

We're excited to share this curriculum with the developer community. Share your progress and connect with others on the journey using the hashtag #ProductionReadyAI. Happy learning!

The Curriculum

Developing Apps that use LLMs

Start with the fundamentals of building applications and interacting with models using the Vertex AI SDK.

Summary: Your First AI Application is Easier Than You Think

Go to lab!
Developing LLM Apps with the Vertex AI SDK

Objective: Build a Gemini chatbot with the Vertex AI SDK, integrating real-time data via external tools and refining outputs with prompt engineering.

Deploying Open Models

Learn to serve and scale open source models efficiently by deploying them on production-grade platforms like Google Kubernetes Engine (GKE), Cloud Run, and Vertex AI endpoints.

Summary: Hands-on with Gemma 3 on Google Cloud

Go to labs!

Serving Gemma 3 with vLLM on Cloud Run
- Objective: Deploy Gemma 3 to Cloud Run using vLLM, leveraging GPU acceleration to expose an OpenAI-compatible API endpoint.
Deploying Open Models on GKE
- Objective: Prototype locally using Ollama, then deploy a scalable inference service to GKE Autopilot using standard Kubernetes manifests.

Developing Agents

Learn to build AI agents that can reason, plan, and use tools to accomplish complex tasks with the Agent Development Kit (ADK).

Summary: Build Your First ADK Agent Workforce

Go to labs!

Building AI Agents with ADK:The Foundation
- Objective: Write the essential code to define and run a basic agent using ADK.
Building AI Agents with ADK:Empowering with Tools
- Objective: Learn how to use tools to interact with external applications and services.
Build Multi-Agent Systems with ADK
- Objective: Orchestrate a complex, automated workflow with a team of specialized agents that work in sequence, in loops, and in parallel.

Securing AI Applications

Master the essential practices for securing your infrastructure, data, and AI-powered endpoints in a production environment.

Summary: Building a Production-Ready AI Security Foundation

Go to labs!

Securing AI Applications
- Objective: Learn to use Model Armor to secure Generative AI applications against prompt injection and data leakage.
Securing Data Used for AI Applications
- Objective: Build an automated pipeline to inspect, classify, and de-identify PII for use in AI development using Sensitive Data Protection.
Securing Infrastructure for AI Applications
- Objective: Secure an AI development environment by implementing network isolation, hardened compute instances, and protected storage.

Deploying Agents

Take your agents to production by deploying them on scalable, managed platforms like Agent Engine, Cloud Run, and Google Kubernetes Engine (GKE).

Summary: From Code to Cloud: Three Labs for Deploying Your AI Agent

Go to labs!

Deploy ADK Agents to Agent Engine
- Objective: Deploy a multi-agent system with Agent Engine without provisioning any infrastructure.
Build and deploy an ADK agent on Cloud Run
- Objective: Containerize an ADK agent and deploy it to a secure public HTTPS endpoint on Cloud Run to experience the speed of a serverless workflow.
Deploy ADK agents to Google Kubernetes Engine (GKE)
- Objective: Deploy an ADK agent to a managed GKE cluster, configuring autoscaling and resource limits using standard manifests.

Evaluation

Discover how to rigorously evaluate the performance of your LLM outputs, agents, and RAG systems to ensure quality and reliability.

Summary: Master Generative AI Evaluation: From Single Prompts to Complex Agents

Go to labs!

Evaluating Single LLM Outputs With Vertex AI Evaluation
- Objective: Run your first automated evaluation job to measure the quality of raw LLM responses.
Evaluate RAG Systems with Vertex AI
- Objective: Assess the performance of a RAG pipeline by measuring both retrieval quality and generation accuracy.
Evaluating Agents with ADK
- Objective: Capture agent execution traces and apply automated evaluation to ensure your agent makes the right decisions.
Build and Evaluate BigQuery Agents using ADK and GenAI Eval Service
- Objective: Build a data-driven agent and test its ability to generate accurate SQL and data insights.

Agent Production Patterns

Learn how to enhance your agent's capabilities with agentic RAG, Model Context Protocol (MCP) tools, and Agent to Agent (A2A) protocol.

Summary: Building Connected Agents with MCP and A2A

Go to labs!

Getting Started with MCP, ADK and A2A
- Objective: Build a specialized currency ADK agent that leverages MCP and A2A communication.
MCP Toolbox for Databases: Making BigQuery datasets available to MCP clients
- Objective: Configure the MCP Toolbox to expose a public BigQuery dataset to an AI agent, enabling it to query and analyze datasets using natural language.
Build a Travel Agent using MCP Toolbox for Databases and Agent Development Kit (ADK)
- Objective: Build a full-stack agent that interacts with a Cloud SQL database, demonstrating how to securely expose relational data to an AI agent.

From Data Foundations to Advanced RAG

Learn to build high-performance RAG systems by mastering the full data lifecycle, from generating vector embeddings within your database to implementing advanced retrieval patterns.

The AI Data Layer Foundation

Discover how to transform your operational databases into AI-ready vector stores. Learn to generate embeddings, perform semantic search, and leverage built-in AI functions directly within AlloyDB and Cloud SQL.

Summary: Coming Soon!

Go to labs!

Getting started with Vector Embeddings with AlloyDB AI
- Objective: Generate embeddings and perform semantic search within AlloyDB to ground Gen AI responses.
Getting started with Vector Embeddings in Cloud SQL for PostgreSQL
- Objective: Generate embeddings and perform semantic search within Cloud SQL for PostgreSQL to ground Gen AI responses.
Getting started with Vector Embeddings in Cloud SQL for MySQL
- Objective: Generate embeddings and perform semantic search within Cloud SQL for MySQL to ground Gen AI responses.
Multimodal Embeddings in AlloyDB
- Objective: Perform semantic search on both text and images using multimodal embeddings in AlloyDB.
AlloyDB AI Operators and Reranking
- Objective: Filter data with natural language and apply reranking to improve search precision using AlloyDB AI functions.
Generate SQL using AlloyDB AI natural language
- Objective: Generate reliable SQL queries from natural language by configuring custom schema context in AlloyDB.

Building the RAG application

Move beyond basic vector search. Learn to architect robust RAG applications by using advanced retrieval strategies and leveraging tools.

Summary: Coming soon!

Go to labs!

Intro to Agentic RAG
- Objective: Build a multi-tool agent that combines retrieval from unstructured documents and structured data to answer reasoning-heavy questions.
AlloyDB Agentic RAG Application with MCP Toolbox
- Objective: Deploy the MCP Toolbox to connect an interactive AI application to an AlloyDB database for grounded responses.
Advanced RAG Techniques
- Objective: Implement and evaluate advanced strategies (Chunking, Reranking, Query Transformation) to improve the precision and recall of your RAG pipeline.

Fine-Tuning

Go beyond prompting and learn how to fine-tune both open and proprietary models to improve performance on specific tasks.

Summary: Coming soon!

Go to labs!

Fine-tune Gemini on Vertex AI
- Objective: Perform supervised fine-tuning on Gemini 2.5 Flash to adapt it for specific tasks like summarization.
Fine-tune Open Source LLMs on Google Cloud
- Objective: Build a production-grade fine-tuning pipeline for Llama 2 on GKE using LoRA and PyTorch.

We're committed to making this a living, evolving resource and will be adding to it over time.

Do you feel something is missing? Tell us here!

Agent Factory Recap: Deep Dive into Gemini CLI with Taylor Mullen

Mollie Pettit — Wed, 17 Dec 2025 00:18:20 +0000

In the latest episode of the Agent Factory podcast, Amit Miraj and I took a deep dive into the Gemini CLI. We were joined by the creator of the Gemini CLI, Taylor Mullen, who shared the origin story, design philosophy, and future roadmap.

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.

What is the Gemini CLI?

The Gemini CLI is a powerful, conversational AI agent that lives directly in your command line. It's designed to be a versatile assistant that can help you with your everyday workflows. Unlike a simple chatbot, the Gemini CLI is agentic. This means it can reason, choose tools, and execute multi-step plans to accomplish a goal, all while keeping you informed. It's open-source, extensible, and as we learned from its creator, Taylor Mullen, it's built with a deep understanding of the developer workflow.

The Factory Floor

The Factory Floor is our segment for getting hands-on. This week, we put the Gemini CLI to the test with two real-world demos designed to tackle everyday challenges.

Onboarding to a New Codebase with Gemini CLI

Timestamp: [02:22]

I kicked off the demos by tackling a problem I think every developer has faced: getting up to speed with a new codebase. This included using the Gemini CLI to complete the following tasks:

Clone the python ADK repository from GitHub with a simple, natural language command
Generate a complete project overview
Utilize the google-docs-mcp (Model Context Protocol) server to save the generated summary directly to Google Docs
Analyze the project's contribution history to understand contribution culture and workflow
Find the best first task for a new contributor

Supercharging Your Research with Gemini CLI

Timestamp: [11:38]

For the next demo, Amit tackled a problem close to his heart: keeping up with the flood of new AI research papers. He showed how he built a personal research assistant using the Gemini CLI to complete the following tasks:

Process a directory of research papers and generate an interactive webpage explainer for each one
Iterate on a simple prompt, creating a detailed, multi-part prompt to generate a better output
Save the complex prompt as a reusable custom slash command Amit also shared gemini-cli-custom-slash-commands, a repository he put together that contains 10 practical workflow commands for Gemini CLI.

The Agent Industry Pulse

Timestamp: [17:26]

Lang Chain 1.0 Alpha: The popular library is refocusing around a new unified agent abstraction built on Lang Graph, bringing production-grade features like state management and human-in-the-loop to the forefront.
Embedding Gemma: Google's new family of open, lightweight embedding models that allow developers to build on-device, privacy-centric applications.
Agentic Design Patterns for Building AI Applications: A new book that aims to create a repository of educational resources around agent patterns.
Gemma 3 270M: A tiny 270 million parameter model from Google, perfect for creating small, efficient sub-agents for simple tasks.
Gemini CLI in Zed Code Editor: The Gemini CLI is now integrated directly into the Z Code editor, allowing developers to explain code and generate snippets without switching contexts.
500 AI Agents Projects: A GitHub repository with a categorized list of open-source agent projects.
Transformers & LLMs cheatsheet: A resource from a team at Stanford that provides a great starting point or refresher on the fundamentals of LLMs.

Taylor Mullen on the Gemini CLI

The highlight of the episode for me was our in-depth conversation with Taylor Mullen. He gave us a fascinating look behind the curtain at the philosophy and future of the Gemini CLI. Here are some of the key questions we covered:

Gemini CLI Origin Story

Timestamp: [21:00]

Taylor explained that the project started about a year and a half ago as an experiment with multi-agent systems. While the CLI version was the most compelling, the technology at the time made it too slow and expensive. He said it was "one of those things... that was almost a little bit too early." Later, seeing the developer community embrace other AI-powered CLIs proved the demand was there. This inspired him to revisit the idea, leading to a week-long sprint where he built the first prototype.

On Building in the Open

Timestamp: [24:14]

For Taylor, the number one reason for making the Gemini CLI open source was trust and security. He emphasized, "We want people to see exactly how it operates... so they can have trust." He also spoke passionately about the open-source community, calling it the "number one thing that's on my mind." He sees the community as an essential partner that helps keep the project grounded, secure, and building the right things for users.

Using Gemini CLI to Build Itself

Timestamp: [27:05]

When I asked Taylor how his team manages to ship an incredible 100 to 150 features, bug fixes, and enhancements every single week, his answer was simple: they use the Gemini CLI to build itself.

Taylor shared a story about the CLI's first self-built feature: its own Markdown renderer. He explained that while using AI to 10x productivity is becoming easier, the real challenge is achieving 100x. For his team, this means using the agent to parallelize workflows and optimize human time. It's not about the AI getting everything right on the first try, but about creating a tight feedback loop for human-AI collaboration at scale.

Gemini CLI under the hood: "Do what a person would do"

Timestamp: [30:58]

The guiding principle, Taylor said, is to "do what a person would do and don't take shortcuts." He revealed that, surprisingly, the Gemini CLI doesn't use embeddings for code search. Instead, it performs an agentic search, using tools like grep, reading files, and finding references. This mimics the exact process a human developer would use to understand a codebase. The goal is to ground the AI in the most relevant, real-time context possible to produce the best results.

On Self-Healing and Creative Problem-Solving

Timestamp: [33:14]

We also discussed the agent's ability to "self-heal." When the CLI hits a wall, it doesn't just fail; it proposes a new plan. Taylor gave an example where the agent, after being asked for a shareable link, created a GitHub repo and used GitHub Pages to deploy the content.

What's Next: The Future is Extensible

Timestamp: [35:19]

The team is doubling down on extensibility. The vision is to create a rich ecosystem where anyone can build, share, and install extensions. These are not just new tools, but curated bundles of commands, instructions, and MCP servers tailored for specific workflows. He's excited to see what the community will build and how users will customize the Gemini CLI for their unique needs.

Your turn to build

The best way to understand the power of the Gemini CLI is to try it yourself.

Check out the Gemini CLI on GitHub to see community projects, file an issue, or contribute. Additionally, don't miss the full conversation: watch the episode and subscribe to The Agent Factory to join us for our next deep dive.

Connect with us

Taylor → LinkedIn, BlueSky, X
Amit → LinkedIn, X, TikTok
Mollie → LinkedIn, BlueSky, X

Build Your First ADK Agent Workforce

Mollie Pettit — Fri, 12 Dec 2025 21:01:49 +0000

The world of Generative AI is evolving rapidly, and AI Agents are at the forefront of this change. An AI agent is a software system designed to act on your behalf. They show reasoning, planning, and memory and have a level of autonomy to make decisions, learn, and adapt.

At its core, an AI agent uses a large language model (LLM), like Gemini to understand and reason. This allows it to process information from various sources, create a plan, and execute a series of tasks to reach a predefined objective. This is the key difference between a simple prompt-and-response and an agent: the ability to act on a multi-step plan.

The great news is that you can now easily build your own AI agents, even without deep expertise, thanks to Agent Development Kit (ADK). ADK is an open-source Python and Java framework by Google designed to simplify agent creation.

To guide you, this post introduces three hands-on labs that cover the core patterns of agent development:

Building your first autonomous agent
Empowering that agent with tools to interact with external services
Orchestrate a multi-agent system where specialized agents collaborate

Build your first agent

This lab introduces the foundational principles of ADK by guiding you through the construction of a personal assistant agent.

You will write the code for the agent itself and will interact directly with the agent's core reasoning engine, powered by Gemini, to see how it responds to a simple request. This lab is focused on building the fundamental scaffolding of every agent you'll create.

Go to the lab!
Lab: Building AI Agents with ADK:The Foundation

Objective: Write the essential code to define and run a basic agent, learning the core structure of ADK.

Empower your agent with tools

An agent without custom tools can only rely on its built-in knowledge. To make it more powerful for your specific use-case, you can give it access to specialized tools. In this lab, you will learn three different ways to add tools:

Build a Custom Tool: Write a currency exchange tool from scratch.
Integrate a Built-in Tool: Add ADK's pre-built Google Search tool.
Leverage a Third-Party Tool: Import and use a Wikipedia tool from the LangChain library.

Go to the lab!
Lab: Empower ADK Agents with Tools

Objective: Learn how to make your agent truly useful by giving it tools to interact with external applications and services.

Build a Team of Specialized Agents

When a task is too complex for a single agent, you can build out a multi-agent team. This lab goes deep into the power of multi-agent systems by having you build a "movie pitch development team" that can research, write, and analyze a film concept.

You will learn how to use ADK's Workflow Agents to control the flow of work automatically, without needing user input at every step. You'll also learn how to use the session state to pass information between the agents.

Go to the lab!
Lab: Build Multi-Agent Systems with ADK

Objective: Orchestrate a complex, automated workflow with a team of specialized agents that work in sequence, in loops, and in parallel.

Summary: Build Your First AI Teammate Today

Ready to build your first AI agents? Dive into the codelabs from this post:

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

These labs are part of the Developing 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.

Agent Factory Recap: Keith Ballinger on AI, The Future of Development, and Vibe Coding

Mollie Pettit — Fri, 12 Dec 2025 16:34:02 +0000

In Episode #6 of the Agent Factory podcast, Vlad Kolesnikov and I were joined by Keith Ballinger, VP and General Manager at Google Cloud, for a deep dive into the transformative future of software development with AI. We explore how AI agents are reshaping the developer's role and boosting team productivity.

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.

Keith Ballinger on the Future of Development

What is "Impossible Computing"?

Timestamp: [01:51]

Keith Ballinger kicked off the discussion by redefining a term from his personal blog: "Impossible Computing." For him, it isn't about solving intractable computer science problems, but rather about making difficult, time-consuming tasks feel seamless and even joyful for developers.

He described it as a way to “make things that were impossible or at least really, really hard for people, much more easy and almost seamless for them.”

AI's Impact on Team Productivity

Timestamp: [05:03]

The conversation explored how AI's impact extends beyond the individual developer to the entire team. Keith shared a practical example of how his teams at Google Cloud use the Gemini CLI as a GitHub action to triage issues and conduct initial reviews on pull requests, showcasing Google Cloud's commitment to AI-powered software development.

This approach delegates the more mundane tasks, freeing up human developers to focus on higher-level logic and quality control, ultimately breaking down bottlenecks and increasing the team's overall velocity.

The Developer's New Role: A Conductor of an Orchestra

Timestamp: [09:57]

A central theme of the conversation was the evolution of the developer's role. Keith suggested that developers are shifting from being coders who write every line to becoming "conductors of an orchestra."

In this view, the developer holds the high-level vision (the system architecture) and directs a symphony of AI agents to execute the specific tasks. This paradigm elevates the developer's most critical skills to high-level design and context engineering—the craft of providing AI agents with the right information at the right time for efficient software development.

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 from both Keith and Vlad.

Showcase: The `Terminus` and `Aether` Projects

Timestamps: [21:02] and [28:17]

Keith shared two of his open-source projects as tangible "demonstration[s] of vibe coding intended to provide a trustworthy and verifiable example that developers and researchers can use."

Terminus: A Go framework for building web applications with a terminal-style interface. Keith described it as a fun, exploratory project he built over a weekend.
Aether: An experimental programming language designed specifically for LLMs. He explained his thesis that a language built for machines—highly explicit and deterministic—could allow an AI to generate code more effectively than with languages designed for human readability.

Vibe Coding a Markdown App

Timestamp: [31:41]

Keith provided a live demonstration of his vibe coding workflow. Starting with a single plain-English sentence, he guided the Gemini CLI to generate a user guide, technical architecture, and a step-by-step plan. This resulted in a functional command-line markdown viewer in under 15 minutes.

Creating a Video with AI

Timestamp: [47:13]

Vlad showcased a different application of AI agents: creative, multi-modal content generation. He walked through a workflow that used Gemini 2.5 Flash Image (also known as Nano Banana) and other AI tools to generate a viral video of a capybara for a fictional ad campaign. This demonstrated how to go from a simple prompt to a final video.

Inspired by Vlad's Demo?

If you're interested in learning how to build and deploy creative AI projects like the one Vlad showcased, the Accelerate AI with Cloud Run program is designed to help you take your ideas from prototype to production with workshops, labs, and more.

Take the next step and register here.

Developer Q&A

Timestamp: [56:37]

We wrapped up the episode by putting some great questions from the developer community to Keith.

On Infrastructure Bottlenecks for AI Workloads

Timestamp: [56:42]

Keith explained that he sees a role for both major cloud providers and a "healthy ecosystem of startups" in solving challenges like GPU utilization. He was especially excited about how serverless platforms are adapting, highlighting that Cloud Run now offers GPUs to provide the same fast, elastic experience for AI workloads that developers expect for other applications.

On Multi-Cloud and Edge Deployment for AI

Timestamp: [_https://youtu.be/I-xS4nw-HfU?feature=shared&t=3496]_

In response to a question about a high-level service for orchestrating AI across multi-cloud and edge deployment, Keith was candid that he hasn't heard a lot of direct customer demand for it yet. However, he called the area "untapped" and invited the question-asker to email him, showing a clear interest in exploring its potential.

On AI in Regulated Industries (Finance, Legal)

Timestamp: [59:13]

Calling it the "billion-dollar question," Keith emphasized that as AI accelerates development, the need for a mature and robust compliance regime becomes even more critical. His key advice was that the human review piece is more important than ever. He suggested the best place to start is using AI to assist and validate human work. For example, brainstorm a legal brief with an AI rather than having the AI write the final brief for court submission.

We concluded this conversation feeling inspired by the future of AI in software development and the potential of AI Agents and the Gemini CLI. For the complete conversation, listen to our full episode with Keith Ballinger now.

Connect with us

Keith → GitHub
Vlad → LinkedIn
Mollie → LinkedIn

Your First AI Application is Easier Than You Think

Mollie Pettit — Wed, 03 Dec 2025 21:02:47 +0000

If you're a developer, you've seen generative AI everywhere. It can feel like a complex world of models and advanced concepts. It can be difficult to know where to actually start.

The good news is that building your first AI-powered application is more accessible than you might imagine. You don't need to be an AI expert to get started. This post introduces a new codelab designed to bridge this gap and provide you with a first step. We'll guide you through the entire process of building a functional, interactive travel chatbot using Google's Gemini model.

Dive into the codelab and build your first AI application today!

Setting the Stage: Your First Project

In this codelab, you'll step into the role of a developer at a travel company tasked with building a new chat application. You'll start with a basic web application frontend and, step-by-step, you will bring it to life by connecting it to the power of generative AI.

By the end, you will have built a travel assistant that can:

Answer questions about travel destinations.
Provide personalized recommendations.
Fetch real-time data, like the weather, to give genuinely helpful advice.

The process is broken down into a few key stages.

Making the First Connection

Before you can do anything fancy, you need to get your application talking to the AI model. An easy way to do this is with the Vertex AI SDK, a complete library for interacting with the Vertex AI platform.

While the Vertex AI SDK is a powerful tool for the full machine learning lifecycle, this lab focuses on one of its most-used tools: building generative AI applications. This part of the Vertex AI SDK acts as the bridge between your application and the Gemini model. Without it, you would have to manually handle all the complex wiring yourself—writing code to manage authentication, formatting intricate API requests, and parsing the responses. The Vertex AI SDK handles all that complexity for you so you can focus on what you actually want to do: send a message and get a response.

In this codelab, you'll see just how simple it is.

Giving your AI purpose with system instructions

Once your app is connected, you'll notice the AI's responses won't be tailored to your purposes yet. One way you can make it more useful for your specific use case is by giving it system instructions.

Hot Tip: Use Google AI Studio to Create Your System Instructions

A great way to develop your system instructions is to leverage Gemini as a creative partner to draft them for you. For example, you could ask Gemini in Google AI Studio to generate a thorough set of instructions for a "sophisticated and friendly travel assistant."

Once you have a draft, you can immediately test it, also in Google AI Studio. Start a new chat and in the panel to the right, set the Gemini model to the one you're using in your app and paste the text into the system instruction field. This allows you to quickly interact with the model and see how it behaves with your instructions, all without writing any code. When you're happy with the results, you can copy the final version directly into your application.

Connecting Your AI to the Real World

This is where you break the model out of its knowledge silo and connect it to live data. By default, an AI model's knowledge is limited to the data it was trained on; it doesn't know today's weather. However, you can provide Gemini with access to external knowledge using a powerful feature called function calling!

The concept is simple: you write a basic Python function (like one to check the weather) and then describe that tool to the model. Then, when a user asks about the weather, the model can ask your application to run your function and use the live result in its answer. This allows the model to answer questions far beyond its training data, making it a much more powerful and useful assistant with access to up-to-the-minute information.

In this lab, we used the Geocoding API and the Weather Forecast API to provide the app with the ability to factor in the weather when answering questions about travel.

Your Journey Starts Here

Building with AI isn't about knowing everything at once. It's about taking the first step, building something tangible, and learning key concepts along the way. This codelab was designed to be that first step. By the end, you won't just have a working travel chatbot—you'll have hands-on experience with the fundamental building blocks of a production-ready AI application. You'll be surprised at what you can build.

Go to the lab!
Lab: Developing LLM Apps with the Vertex AI SDK

Objective: Learn to build a chatbot using the Vertex AI SDK and Gemini, integrate real-time data with external tools, and refine model output with prompt engineering.

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

From Prototype to Production

This lab is also the first 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.

From Skeptic to Believer: A Process-Driven Approach to Vibe Coding

Mollie Pettit — Wed, 05 Nov 2025 23:05:11 +0000

I’ll admit, I've in the past had a negative reaction to the term vibe coding. (And in some circumstances, I still do.) It often brought to mind an engineer carelessly committing code that’s buggy or inefficient without proper checks.

My perspective changed after our conversation with Keith Ballinger, VP and General Manager at Google Cloud on episode 6 of the Agent Factor podcast. He showed us that his approach to vibe coding isn't about chaos; it's about a surprisingly structured template that turns a vague 'vibe' into a concrete plan.

Demo: Vibe coding a command line Markdown viewer with the Gemini CLI

My biggest takeaway is that vibe coding is more nuanced than I first thought. I now see its value on a spectrum: it's a powerful tool for exploration when you're in unfamiliar territory, and a tool for acceleration when you're an expert in your domain. It's a workflow for both creative ideation and efficient execution.

The Template: a structured workflow for AI-assisted development

On the show, Keith suggested on a whim that we vibe-code a command-line markdown viewer from scratch using the Gemini CLI. This turned out to be my favorite moment of the show. What stuck out most to me was his methodical approach (which I am totally stealing, btw).

Here’s a breakdown of the template he used:

Step 1: start with the user, not the code

Before writing a single line of code, Keith’s first move was to define the user experience. He prompted the Gemini CLI to create a UserGuide.md. Timestamp: [01:49]

The demo prompt:

I want to build a command line markdown viewer. It should paginate long markdown files, have some syntax highlighting, and does not include any editing features. Write me a user guide and save it to UserGuide.md. Wait for my review, don't write any code yet.

Why I like it: Doing this as a first step forces clarity on the project's goals from the end-user's perspective. It establishes a clear definition of "done" before delving into technical details. It also ensures the LLM proceeds incrementally and doesn't jump ahead.

Step 2: get a programming language suggestion

Next, Keith requested advice on what programming language to use for this project. Timestamp: [03:51]

The demo prompt:

Let's build a technical design for mdview. What language do you suggest we use? Give me three options and your final recommendation. And after I tell you, we'll write the technical design.

Why I like it: It can be tempting to default to familiar tools. However, this approach can sometimes lead to using the wrong tool for the job. This step serves as a helpful reminder to consider alternatives, whether by asking the LLM or evaluating options yourself. When the best approach involves an unfamiliar tool, it presents an opportunity to acquire a new skill!

Step 3: create a technical blueprint

Once the user guide was approved, he had the agent act as a junior architect, suggesting technologies and outlining a technical design in an Arch.md file. Timestamp: [05:00]

The demo prompt:

Let's author a technical design and save it to Arch.md. Be very detailed. Wait for my review before coding.

Why I like it: This separates the high-level design from the implementation. It creates a natural checkpoint for human review, allowing for changes and approval of the technical direction before committing to code.

Step 4: generate a detailed, check-list style plan

This was the core of the template. Keith asked the agent to break down the entire project into a series of discrete, numbered tasks in a plan.md file. Timestamp: [07:00]

The demo prompt:

Now let's create a detailed task plan and save it to plan.md. Include in the plan.md some general workflow

Why I like it: This is the step that turns a fuzzy idea into an actionable project plan. It creates a clear roadmap for both the developer and the AI, preventing the agent from going off-track or attempting to build everything simultaneously.

Step 5: give the AI meta-instructions on how to work

I found this to be a subtle but powerful part of the process. In addition to asking the AI to execute the plan, this prompt told it how to use the plan.

The demo prompt:

Update plan.md when each task is completed with implementation notes. Update arch.md with any design changes. I will review, and then we'll start.

Why I like it: By instructing the agent to update the plan.md file with checkboxes and implementation notes after each step, he created a self-documenting workflow. This is valuable because it preserves the session's state, making it easy to review progress, debug, or even step away and resume the project another day. It also keeps other documents up to date with changes.

Bonus step: add personality! 🤪

The part of this demo that tickled me most is when Keith decided to inject some personality into the interaction. This was a fun reminder that we can adjust how the AI interacts with us to enhance our experience. Timestamp: [09:23]

The demo prompt:

From here on out, address me as K-bro. And use puns liberally.

The AI immediately obliged, quipping things like, "Alright, K-bro, consider it done!" and "It's time to make this code look rich" (punning on the use of the rich library).

Why I like it: Adding these kinds of personality adjustments could add intermittent giggles and delight into the driest of projects. (Listen and you'll hear me laughing in the background at this part. :p) Why not make the entire development process more enjoyable, creative, and feel less like working with a sterile machine?

❓Question for you: What ideas do you have for injecting personality into your workflow? I'd love to see your examples!

Beyond the fun, the demo left me with a few key takeaways about how I'll approach AI-assisted development from now on.

My takeaways

It's about exploration and acceleration

Keith’s workflow helped me reframe vibe coding. Instead of seeing it as just a tool for prototyping, I now see its value on a spectrum that goes from pure exploration to powerful acceleration.

For work you're not familiar with, like learning a new language or system, it’s a tool for exploration. The ability to experiment and iterate at a speed that was never before possible is a massive advantage. Projects you might have put aside because the learning curve was too steep are now accessible.

For work you already know inside and out, it's a tool for acceleration. As Keith's demo showed, the most productive AI users are experts in their domain. They can offload the mundane parts of their job—like writing boilerplate code or hundreds of tests—making them faster and, frankly, happier.

This interview made me want to go out and build more things. To experiment more, prototype more, and see what I can quickly whip together to solve problems in my own work and life. I hope it inspires you as well. (Get started with Gemini CLI.)

I love process

This is something I already knew about myself. I've always appreciated the value of process, not for its own sake, but for its ability to improve collaboration and efficiency. When I identify areas where a little structure could greatly enhance how people work together, I am driven to implement it, regardless of my official role or priority.

I don't think I realized how much this type of structure was missing from my own iterative LLM workflow. And not just for development, but for any task I'm trying to complete with an AI.

What else?

There are many effective ways to structure an iterative LLM / vibe coding workflow. I am curious about what other approaches people have found effective.

❓Question for you: What other workflows have you found effective?

For our complete conversation, watch Agent Factory S1E6 or check out the Episode Recap Blog Post for an overview of episode segments with links and timestamps.

DEV Community: Mollie Pettit

Building Connected Agents with MCP and A2A

The Foundations of ADK, MCP, A2A

Connecting to Data with MCP

Expose a BigQuery database to an MCP Client

Expose a CloudSQL database to an MCP Client

From Prototype to Production

Agent Factory Recap: Build AI Apps in Minutes with Google's Logan Kilpatrick

The Build Experience in Google AI Studio - What is it?

The Factory Floor

Vibe Coding a Virtual Food Photographer

Grounding with Google Maps

Exploring the AI Studio Gallery

"Yap to App": A Conversational Pair Programmer

The Agent Industry Pulse

Logan Kilpatrick on the Future of AI Development

Grounding with Google Maps

From Models to Systems: The Next Frontier

Conclusion

Your turn to build

Connect with us

Production-Ready AI with Google Cloud Learning Path

Why We Built This: Bridging the Prototype-to-Production Gap

The Curriculum

Developing Apps that use LLMs

Deploying Open Models

Developing Agents

Securing AI Applications

Deploying Agents

Evaluation

Agent Production Patterns

From Data Foundations to Advanced RAG

The AI Data Layer Foundation

Building the RAG application

Fine-Tuning

Agent Factory Recap: Deep Dive into Gemini CLI with Taylor Mullen

What is the Gemini CLI?

The Factory Floor

Onboarding to a New Codebase with Gemini CLI

Supercharging Your Research with Gemini CLI

The Agent Industry Pulse

Taylor Mullen on the Gemini CLI

Gemini CLI Origin Story

On Building in the Open

Using Gemini CLI to Build Itself

Gemini CLI under the hood: "Do what a person would do"

On Self-Healing and Creative Problem-Solving

What's Next: The Future is Extensible

Your turn to build

Connect with us

Build Your First ADK Agent Workforce

Build your first agent

Empower your agent with tools

Build a Team of Specialized Agents

Summary: Build Your First AI Teammate Today

Agent Factory Recap: Keith Ballinger on AI, The Future of Development, and Vibe Coding

Keith Ballinger on the Future of Development

What is "Impossible Computing"?

AI's Impact on Team Productivity

The Developer's New Role: A Conductor of an Orchestra

The Factory Floor

Showcase: The Terminus and Aether Projects

Vibe Coding a Markdown App

Creating a Video with AI

Inspired by Vlad's Demo?

Developer Q&A

On Infrastructure Bottlenecks for AI Workloads

On Multi-Cloud and Edge Deployment for AI

On AI in Regulated Industries (Finance, Legal)

Connect with us

Your First AI Application is Easier Than You Think

Setting the Stage: Your First Project

Making the First Connection

Giving your AI purpose with system instructions

Hot Tip: Use Google AI Studio to Create Your System Instructions

Connecting Your AI to the Real World

Your Journey Starts Here

From Prototype to Production

From Skeptic to Believer: A Process-Driven Approach to Vibe Coding

The Template: a structured workflow for AI-assisted development

Showcase: The `Terminus` and `Aether` Projects