Day 2 of Google’s AI agents intensive: tools, MCP servers, and real-world actions

Day 1 of Google’s AI Agents Intensive was all about setup. Day 2 is where things start to feel powerful: you connect tools, wire up APIs, and turn a simple assistant into an agent that can actually do things in the real world.

This walkthrough recaps the main ideas from Day 2, focusing on Antigravity, the command-line interface (CLI), and the Google Developer Knowledge MCP server. Even if you’re following along late or didn’t get the original course emails, you can still replicate the core steps and understand how these pieces fit together.

From basic assistant to action-taking AI agent

On Day 2, the focus shifts from just chatting with an AI to giving it real superpowers. That means:

• Connecting external APIs so the agent can pull in live data or call services

• Enabling code execution so it can generate, run, and refine scripts or utilities

• Using tools like MCP servers to safely expose specialized capabilities

Together, these turn a conversational model into an agentic system—something that can plan, call tools, and carry out multi-step tasks instead of just answering questions.

Day 2 assignments and resources

Day 2 is structured similarly to Day 1: you work through a podcast-style summary, a white paper, and a hands-on code lab. If you didn’t receive an email, you can still access everything from the Kaggle course discussion area under the Day 2 assignment.

The Day 2 materials focus on:

• A white paper explaining agent tools and interoperability

• Using the Antigravity CLI more deeply

• Exploring the Google Developer Knowledge MCP server inside Antigravity

If the white paper feels dense, you can drag the PDF into a notebook and ask an AI model to summarize it. That’s a great example of using AI as a reading assistant before you start building agents.

Getting comfortable with the Antigravity CLI

By Day 2, Antigravity should already be installed from the previous setup. If not, you’ll need to install the Antigravity CLI first (with the appropriate command for PowerShell or Windows Command Prompt) and then verify the installation.

Checking your Antigravity CLI version

Open Command Prompt as administrator and run:

• agy --version to confirm the CLI is installed and see the version

• agy to launch the interactive Antigravity CLI

Once it signs in, you can type a simple prompt like “Give me a famous quote about artificial intelligence” to confirm everything is working.

Exploring CLI commands and settings

Inside the CLI, typing / shows available options, and /help gives you a list of commands and shortcuts. You can navigate with the arrow keys to explore:

• Config – adjust settings like animation speed and other preferences

• Trusted workspaces – define which folders the agent is allowed to work in

• Tool permissions – control what the agent is allowed to do

These settings are stored in a JSON file under the Antigravity configuration directory (for example, a settings.json file for the CLI). You can open it to see how Antigravity tracks your preferences.

Non-interactive and shell modes

The CLI also supports different usage modes:

• Non-interactive mode – you send a single prompt and get a single response, with no ongoing conversation context.

• Shell mode – lets you use Antigravity as a layer on top of your terminal. You can enter and exit this mode to move between normal command-line usage and AI-assisted workflows.

Understanding these modes is important when you start building scripts or automations that call the CLI programmatically.

Using Antigravity to scaffold a GitHub project

One of the suggested Day 2 exercises is to let Antigravity help you set up a full Git project and push it to GitHub. The prerequisites include:

• Git installed on your machine

• Antigravity CLI

• Python 3

• GitHub CLI (gh) configured with your account

The workflow looks roughly like this:

• Create a new project folder

• Ask Antigravity to initialize a Git repository

• Generate a .gitignore file

• Create a remote repository on GitHub

• Push your local code to GitHub

Once it’s done, you’ll see your project live on GitHub. This kind of “vibe coding” workflow—letting an AI agent handle boilerplate setup while you focus on intent—is becoming more common across tools. If you’re interested in similar approaches beyond Google’s stack, you might also like these Claude Code tools that make vibe coding actually work.

What is an MCP server and why does it matter?

A big theme of Day 2 is MCP servers. MCP (Model Context Protocol) is a way to expose tools and data sources to AI models in a structured, interoperable way.

Instead of hard-coding API calls directly into your agent, an MCP server acts as a bridge between the model and an external system. It defines:

• What tools are available (for example, “search documents” or “get document”)

• How those tools should be called

• What kind of data they return

This makes it easier to reuse tools across different agents and environments, and it keeps your integrations cleaner and more secure.

Enabling the Google Developer Knowledge API

Day 2 uses a specific MCP server: the Google Developer Knowledge MCP server. This gives your agent access to structured information from Google’s developer documentation.

Step 1: Create or select a Google Cloud project

First, you need a Google Cloud project:

• Go to the Google Cloud Console

• Open the “Manage resources” page

• Create a new project (you can name it anything you like)

Once the project is created, make sure it’s selected in the top navigation bar before moving on.

Step 2: Enable the Developer Knowledge API

Next, enable the API that powers the MCP server:

• From the code lab or documentation, follow the link to “Enable the Developer Knowledge API”

• Confirm that the correct project is selected

• Click Enable

Billing is not required for this particular setup, which is explicitly called out in the course. That makes it safer and easier for experimentation.

Step 3: Create an API key

Now you need an API key that Antigravity will use to talk to the Developer Knowledge API:

• In the Google Cloud Console, go to APIs & Services → Credentials

• Click Create credentials → API key

• Give the key a descriptive name, such as “Antigravity Developer Knowledge API”

• Save the key somewhere secure and never share it publicly

This key is what you’ll paste into your Antigravity MCP configuration.

Configuring the Developer Knowledge MCP in Antigravity

With the API key ready, the next step is to wire the MCP server into Antigravity. You’ll touch three places: the Antigravity IDE, the Antigravity app, and the CLI.

Adding the MCP server in Antigravity IDE

In the Antigravity IDE:

• Open the IDE and go to the right-hand panel where MCP servers are listed

• Click Manage MCP servers

• Choose View raw config to see the underlying JSON configuration

• Paste in the provided MCP server configuration from the code lab

• Insert your API key into the appropriate field

After saving, refresh the MCP servers list. You should now see the Google Developer Knowledge MCP server marked as installed.

Verifying tools in the Antigravity app

Next, open the main Antigravity app:

• Click the settings icon (bottom left)

• Navigate to Customizations

• Confirm that the Developer Knowledge MCP tools are visible and enabled

You should see tools like:

• Search documents

• Answer query

• Get document

These are the capabilities your agent can now call when it needs information from Google’s developer docs.

Connecting the CLI to the MCP server

Finally, you connect the CLI:

• Open Antigravity IDE settings again

• Locate the CLI execution command and user settings for the CLI

• Ensure the MCP configuration is shared so the CLI can see the same servers

When you launch the CLI and type /, you should now see the Developer Knowledge MCP server listed under MCP-related commands.

Testing the Developer Knowledge MCP from app, IDE, and CLI

Day 2 encourages you to test the integration from all three environments to understand how consistent the experience is.

Testing in the Antigravity app

In the app:

• Start a new conversation

• Paste a test prompt from the code lab that specifically targets Google developer documentation

• When prompted, allow the app to use the Developer Knowledge MCP tools

You should see a message indicating that the agent is “looking at Google Developer Knowledge” or similar, confirming that it’s calling the MCP server rather than just guessing from the base model.

Testing in the IDE

In the IDE, repeat a similar test:

• Open a project

• Start a chat panel or agent session

• Use a prompt that requires developer documentation

Again, you should see the IDE calling the Developer Knowledge MCP, and the responses should be grounded in official docs.

Testing in the CLI

Finally, test from the CLI:

• Open Command Prompt as administrator

• Run agy to start the CLI

• Paste a test prompt that uses the Developer Knowledge tools

The CLI will again show that it’s querying Google Developer Knowledge via the MCP server. If configured correctly, all three environments—app, IDE, and CLI—behave consistently.

Cleaning up: disabling APIs and deleting keys

Day 2 also emphasizes good security and cleanup practices. When you’re done experimenting:

• Go to the API & Services → Dashboard in Google Cloud

• Select the Developer Knowledge API and click Disable

• Go to API & Services → Credentials, find your API key, and delete it (you may need to type “delete” to confirm)

Cleaning up unused keys and disabling APIs you no longer need is a best practice, especially when you start working with more powerful or sensitive integrations.

Why Day 2 matters for building real AI agents

Day 2 can feel configuration-heavy, but there’s a clear underlying goal: learning how to connect tools and data sources so your agent can take meaningful action.

By the end of this day, you’ve seen how to:

• Use the Antigravity CLI, IDE, and app together

• Configure and consume an MCP server

• Safely manage API keys and cloud resources

• Let an AI agent scaffold real projects, like Git repositories pushed to GitHub

These are the foundations of modern agentic systems: models that don’t just talk, but integrate with your tools, code, and infrastructure. If you’re interested in how Antigravity fits into Google’s broader agent strategy, it’s worth checking out how the Antigravity 2.0 update pushes developers into the AI agent era.

With tools and interoperability in place, you’re ready for the next steps in the course: building more capable, autonomous workflows on top of these foundations.