How to Build Agents with Vertex AI Builder

Vertex AI Agent Builder is part of Google Cloud’s Vertex AI suite. It combines no-code tools with a developer toolkit so you can build, test, and scale AI agents. You can build AI agents with Vertex AI Agent Builder in three main steps: explore pre-built templates in Agent Garden, develop custom logic using the Agent Development Kit (ADK), and deploy your agent through Agent Engine. This tutorial walks you through building a complete agent from setup to production deployment using Google Cloud’s Vertex AI platform.

What is vertex ai agent builder?

At its core, Vertex AI Agent Builder is a platform for creating and deploying AI-powered agents. Unlike traditional frameworks where you write everything in code, Agent Builder offers:

• No-code setup: Configure agents through a simple interface.
• Low-code flexibility: Extend agents with Python code using the Agent Development Kit (ADK).
• Enterprise readiness: Deploy agents at scale with monitoring, evaluation, and security baked in.

Think of it as having an AI agent factory: you design the blueprint, and Vertex AI handles the infrastructure, scaling, and deployment.

Exploring agent garden in vertex ai agent builder

If you’re new to Vertex AI Agent Builder, the best place to start is the Agent Garden. It is a library of sample agents and tools that you can browse and customize.

• Want a customer support bot? There’s a template.
• Need a knowledge assistant? You’ll find one here.

You can pick a sample agent, modify its behavior, and launch it right away. It’s a great way to learn best practices without starting from zero. In the coming section we’ll use this Agent Garden only to clone an AI Agent, run it locally and in the end deploy it on our cloud services too.

Building an agent with ADK (Agent Development Kit)

For developers who want more control, Vertex AI offers the ADK (Agent Development Kit). With the ADK, you can define logic and orchestration in Python.

Instead of hundreds of lines of code, you can often build a functional agent in fewer than 100.

For example, we will be using the Blog Writer agent given by Google. To download it locally go to the Agent Garden. To set this up locally just download the agent from the given link and run the following commands:

First, we need to install uv. We can do this using pip:

pip install uv

Copy to clipboard
Copy to clipboard

Once uv is installed, we can install the project’s dependencies like:

uv pip install -r requirements.txt

Copy to clipboard
Copy to clipboard

Note: You might have to create an environment to run the above command.

This will create a virtual environment for the project and install all the required libraries.

Once this is done, run the following command to check if the agent is being hosted locally. At this stage, the agent won’t function yet, but don’t worry, we’ll address that in the upcoming sections.

uv run adk web

Copy to clipboard
Copy to clipboard

Adding tools to your vertex ai agent builder

Agents are most useful when they can interact with the real world. With Vertex AI Agent Builder, you can add:

• Grounding via Google Search: Agents can fetch up-to-date information.
• RAG (Retrieval-Augmented Generation): Agents can reference your own documents.
• Custom APIs: Connect to company data or services.
• Code execution: Allow agents to perform calculations or run scripts.

Adding tools ensures your agents don’t just generate text but can act with purpose and accuracy.

Deploying with vertex ai agent engine

Our agent is ready, we now have to deploy it through the Vertex AI Agent Engine. This runtime environment manages:

• Sessions and state: Keep conversations consistent.
• Evaluation: Test and measure your agent’s performance.
• Scaling: Handle traffic seamlessly in production.
• Security and compliance: Run agents in enterprise-ready environments.

With just a few configurations, you can go from testing locally to deploying an agent that can handle real users at scale. The deployment process is split into a few processes which we will discuss now!

Configuring cloud

• Open the google cloud website.

• Open Console and create a new project.

• Once created, select it like this:

• Search for Vertex AI and click on it.

• On your dashboard, click on enable all recommended API, like this:

• Then search for Bucket and select the cloud storage, like:

• After that, press the “Create” button and give this bucket a name like this:

• Don’t change any of the default options—just create the bucket.

• Then, return to the root menu by clicking the Google Cloud icon, and copy your Project ID.

• Create a .env file in the root directory of the project and paste this ID in your project .env like this:

• Go back to the bucket page, copy the name of your bucket, and paste it into your .env file like this:

Note: Keep GOOGLE_CLOUD_LOCATION set to us-central1, as this is the default location. You can change it later when authenticating your Google Cloud CLI, but for now, it’s best to leave it as the default.

Connecting the local agent with the cloud

Our next task is to connect our agent with the cloud service. Open this Google sdk installation link and download the zip file for your respective system platform. We are running on MacOS arm64 so we’ll download the respective zip, like:

Just follow the download instructions, and once download is done open your project terminal and run:

./google-cloud-sdk/bin/gcloud init

Copy to clipboard
Copy to clipboard

And, once you login to your account, it will ask you the project name to choose where we’ll choose the project we created for our agent at start, like:

With this we have connected the local agent with our cloud and now you can go back to your project terminal and run:

adk web

Copy to clipboard
Copy to clipboard

This command will locally host the agent for you and it’s ready to test! Give it a topic to write a blog on, like:

Note: If you see this error while prompting the agent, it means the Google Cloud CLI hasn’t been authenticated correctly. Run the following command again and ensure that all required permissions are granted:

gcloud auth application-default login  
## Make sure to give account all permissions

Copy to clipboard
Copy to clipboard

Deploying to agent engine

Our final task is to deploy this agent on the Agent Engine using Google Cloud. But before we dive in, let’s answer a simple question “Why are we deploying it to the Agent Engine now?”

When we tested the agent locally, it worked perfectly on our machine. However, if we want to share it with people worldwide, we need to make it accessible online. Deploying to the Agent Engine allows us to turn a local project into a globally available service.

To deploy your agent, run the following command in your project directory:

adk deploy agent_engine  
--project=my-cloud-project-xxxxx  
--region=us-central1  
--staging_bucket=gs://my-cloud-project-staging-bucket-name  
--display_name="My Agent Name"  
/multi_tool_agent

Copy to clipboard
Copy to clipboard

In this command, /multi_tool_agent refers to the name of your agent. In our case, we used blogger_agent.

Make sure to replace the placeholders (my-cloud-project-xxxxx, bucket name, and display name) with your own project details before running the command.

Once you press Enter, the adk will begin deploying your agent to the staging bucket you created earlier.

Once the command finishes running, you’ll receive a link to monitor the deployment progress.

Click on the link, and you’ll be taken to a log interface, where you can track the status of your deployment in real time. It will look something like this:

Next, go back to the Vertex AI dashboard, open the Agent Engine, and click on your agent’s name.

Once you open the agent, take note of the API URL. This URL provides both the Query URL and the Stream Query URL, which you’ll use to connect your backend and run RAG queries.

If you’d like to dive deeper into Retrieval-Augmented Generation (RAG), check out our free course on Creating AI Applications using RAG. And, with this we are done with the deployment of our Agent AI using the Vertex AI and Google Cloud.

Real-world applications of vertex ai agent builder

Vertex AI Agent Builder isn’t limited to small projects or demos, it’s already making an impact across industries. Here are some common use cases:

• Customer Support Agents: Automate responses to frequently asked questions and reduce the load on human support teams.
• Document Assistants: Search, retrieve, and summarize information from large enterprise knowledge bases.
• Enterprise Search: Provide smarter, context-aware queries across internal data sources.
• Multi-Agent Systems: Coordinate specialized agents that work together to handle complex workflows.

For enterprises, the real value lies in the scalability, security, and compliance offered by Google Cloud, making Agent Builder a reliable choice for production environments.

Best practices & limitations

When building with Vertex AI Agent Builder, keep these practices in mind:

Best Practices:

• Start with clear, simple instructions.
• Test agents regularly in real-world scenarios.
• Use grounding methods such as RAG or APIs to reduce hallucinations.
• Monitor usage and costs with Google Cloud’s billing tools.

Limitations:

• Currently available in fewer regions compared to global frameworks.
• Some advanced features may require enterprise-level billing.
• Not all APIs are supported out of the box, and you may need to integrate custom ones.

The key is to prototype quickly but test thoroughly before deploying at scale.

Conclusion

Vertex AI Agent Builder makes it possible to design, build, and deploy AI agents faster than ever. Whether you’re starting with Agent Garden templates or building custom solutions with the Agent Development Kit, Vertex AI Agent Builder provides the tools enterprises need for production-ready AI agents. Combining no-code tools like Agent Garden with developer options like the ADK makes it flexible enough for beginners and powerful enough for enterprises.

To deepen your skills, you can learn about Retrieval-Augmented Generation (RAG), practice formatting responses with the Front-End Engineer Career Path, and strengthen your ability to work with APIs and queries through the Back-End Engineer Career Journey.

Frequently asked questions

1. Is Agent Builder free or paid?

You need a Google Cloud account with billing enabled. Some usage may be free, but production deployments incur costs.

2. Do I need to code to build agents?

No. You can use no-code tools in Agent Garden. But coding with ADK gives you more flexibility.

3. How to create an agent in Vertex AI?

To create an agent in Vertex AI Agent Builder, start by accessing Agent Garden in the Google Cloud console. Select a pre-built template that matches your use case, or build from scratch using the Agent Development Kit (ADK). Configure your agent’s instructions and tools, then deploy it through Vertex AI Agent Engine for production use. The entire process, from template selection to deployment, is covered in the tutorial above.

4. What models does Agent Builder support?

It supports Google’s Gemini and PaLM models, with more being added over time.

5. How does Vertex AI Agent Builder compare with LangChain or Rasa?

LangChain is a developer-first framework, while Vertex AI Agent Builder offers more managed infrastructure. Rasa is focused on dialogue systems, while Vertex covers broader agent use cases.