Google Cloud Explains Agent Harnesses Behind Antigravity

Published Sep 16, 2026 by Venkatraman Chandrasekaran |Dev Tools

Google Cloud Explains Agent Harnesses Behind Antigravity, Claude Code, and Cursor

Google Cloud Tech has released a new episode of The Agent Factory that argues the next bottleneck in AI coding is not the model. It is the stack around the model.

The video, titled Agent Harnesses Explained: Inside the Stack Behind Antigravity, Claude Code & Cursor, breaks down how tools such as Google Antigravity, Anthropic’s Claude Code, and Cursor actually get work done. The central claim is simple: an AI agent is not just a large language model. An agent is a model plus a harness.

That distinction already matters for software buyers. Many teams now have access to strong coding models. Fewer teams have a reliable way to give those models tools, memory, tests, domain knowledge, and safety limits so they can complete multi-step engineering work without constant human prompting.

What an agent harness is

In the episode, an agent harness is defined as everything surrounding the model that lets it take action instead of only generating text.

That surrounding layer typically includes:

tools the agent can call, such as file editors, terminals, browsers, and cloud APIs
context discovery, so the agent can find the right files, docs, and prior decisions
memory across steps or sessions
execution in a real environment, not just a chat window
verification loops, such as running tests and reading the failure output
guardrails that block destructive or out-of-policy actions

The practical example used in the video is straightforward. A model can describe how to check the weather. A harnessed agent can fetch the weather, use that result in the next step, and continue until the task is finished.

Google engineer Ryan Lopopolo, who popularized the term harness engineering, frames the job as curating context and tools so the model understands what “good” looks like without being re-prompted on every turn. In the episode, he describes a shift from writing implementation details by hand toward writing specifications, tests, documents, and static checks that agents can use as constraints.

Lopopolo is now Principal Engineer for Agentic Google Cloud Platform. He previously worked on agent-driven development workflows at OpenAI and maintains an open field guide on harness engineering.

Why this matters for Claude Code, Cursor, and Antigravity?

The episode treats Claude Code, Cursor, and Antigravity as different products built on the same underlying idea.

Each product wraps a model in a working environment:

Claude Code is a terminal-first coding agent that operates directly against a repository.
Cursor is an editor-centered agent workflow with repo context and iterative edits.
Google Antigravity is Google’s agent environment for software engineering, including orchestration features such as Boost.

The video’s point is that these products compete less on raw model IQ and more on how well their harnesses manage long-running work. If an agent can inspect a repo, edit files, run tests, recover from failures, and stay inside safety limits, the model becomes much more useful. If the harness is thin, even a strong model stalls.

That view matches a broader shift already visible across the coding-agent market: developers still make most of the planning decisions, while agents increasingly handle execution decisions.

Linear harnesses versus closed-loop harnesses

Billy Jacobson’s code segment uses Google’s Agent Development Kit (ADK) to show two common harness patterns.

Linear harness. The agent follows a fixed path. It inspects an input, calls a tool, and returns a result. This pattern is easier to debug and works well for deterministic jobs such as parsing a file, extracting fields, or producing a one-pass summary.

Closed-loop harness. The agent keeps working until a success condition is met. A typical coding loop looks like this: edit code, run tests, read the failure, fix the next issue, and repeat. This is the pattern behind agents that can debug, refactor, or implement a feature across multiple files.

Jacobson also shows a guarded ADK setup. In that version, the harness can compact memory as the task grows and block dangerous actions, such as destructive file deletes or unsafe database operations, before they reach the environment.

The design lesson is that autonomy is not a personality trait of the model. It is an engineering property of the loop.

The three-layer stack Google is promoting

Smitha Kolan closes the episode with a three-layer recipe for high-performing agents.

1. Model layer: Gemini 3.8 Flash
Google positions Gemini 3.8 Flash as a fast workhorse model for agent loops rather than a one-shot chatbot. The model is generally available, supports a 1,048,576-token context window, and is tuned for software engineering and multi-step tool use. Google says it is now the default model for Antigravity’s managed agents.

The reason a Flash-class model matters here is cost and latency. Closed-loop agents may run many turns. A cheaper, faster model can complete more verify-and-fix cycles before the task becomes too slow or too expensive.

2. Harness layer: Antigravity Boost
Boost is Antigravity’s on-demand multi-agent reasoning mode. Instead of leaving a hard bug to a single chat turn, /boost breaks the problem down, assigns focused work to sub-agents, and runs separate verification passes. Google documents it as a three-phase pipeline: strategy, isolated execution, and independent checking.

This is the orchestration layer. It is what turns one model into a coordinated team when the task is too large for a single pass.

3. Knowledge layer: Google Skills
The third layer is domain knowledge packaged as skills. Google’s open google/skills repository provides Agent Skills and plugins for Google Cloud, Firebase, Flutter, Maps, security, databases, and other product areas. The repo is Apache 2.0 licensed and can be installed into multiple harnesses, including Antigravity, Claude Code, and Codex.

A skill is usually a folder with a SKILL.md file. The file tells the agent when to use the skill, what procedure to follow, and which conventions matter. That lets teams add current product knowledge without waiting for the next model training run.

Kolan’s argument is that teams should treat these three layers as separate design choices. Pick a model that can loop quickly. Wrap it in a harness that can plan, tool-call, and verify. Then give it the exact knowledge it needs for your cloud, framework, or internal system.

What software teams should take from the episode?

The episode is a product explainer, but it also doubles as a buying and architecture checklist.

Teams evaluating coding agents should ask:

Does the agent run in a closed loop, or does it stop after one pass?
Can it use the repo, tests, terminal, and internal docs without a new prompt at every step?
Are guardrails enforced in the harness, or only requested in the prompt?
How is domain knowledge supplied: model memory, retrieval, skills, or tribal knowledge in Slack?
When a task gets hard, can the system orchestrate sub-agents and verify their work?

For Google Cloud customers, the recommended path in the video is concrete: use Gemini 3.8 Flash for high-frequency loops, Antigravity Boost for deep reasoning and multi-agent coordination, and Google Skills for product-specific procedures. ADK is the open framework shown for teams that want to build a custom harness instead of adopting a packaged coding agent.

The larger industry implication is that model comparisons will keep mattering, but they will not be enough. As Claude Code, Cursor, Antigravity, Codex, and open-source agents converge on similar models and similar editor or terminal surfaces, the durable difference will be the harness: how well the system turns a capable model into reliable software work.

Related resources:

Venkat