The Agent Factory — Agent Harnesses Explained (Google Cloud Tech, September 2026)
▶ Watch on YouTube · Google Cloud Tech · 30:58
What exactly is an agent harness, and why is it the secret to fully autonomous coding? If your coding agents are hitting a wall, the problem might not be the model you are using, it might be the stack… First, we sit down with Ryan Lopopolo, the Google engineer who coined the term “agent harness”. We will discuss why he hasn’t manually written code since May, how to apply senior engineering principles to AI agents, and how agents are being deployed to operate Google Cloud.
— Channel description, Google Cloud Tech (The Agent Factory)
TL;DR
The most important thing in this video is a fact about a person, not a concept: Ryan Lopopolo now works at Google. The wiki has carried him as Member of Technical Staff at OpenAI (Codex) since his promotion in June. Here he is interviewed by Tilde Thurium as “a Googler”, says “Holding strong here at Google — it’s been eight weeks here for me” (so joining around mid-July 2026), and describes his work as building “the best agents to help you operate your Cloud.” The entity page has been corrected.
Beyond that, the episode is three segments: the Thurium–Lopopolo interview (the substance), a live code walkthrough by Billy, and a tooling round-up by Smitha.
The coinage question, asked directly
Thurium puts it to him: “How did harness become a term? And is it true that you’re the person that coined it?” His answer confirms it and dates it — “We published some great work on it in February of this year, and it kind of has taken the industry by storm.”
This bears on a live thread in the corpus. GitHub’s developer advocates told their audience the term came from “Harrison from LangChain… and Viv from their team”, and the wiki has recorded a Feb-11 / Feb-17 co-coinage window between Lopopolo’s OpenAI essay and Trivedy’s LangChain post. On priority the question now resolves: the coiner says so on camera, six days before the GitHub episode’s anniversary, and nobody has contested it. What the GitHub episode remains excellent evidence for is how lossily attribution propagates — within seven months, the wrong vendor was being credited by people paid to track the field.
He also extends his own headline number. The essay reported five months with zero manually-written code; here it is “I don’t think I’ve actually opened an editor at all since around May of last year” — well over a year, across an employer change.
His June DevCon talk gave the corpus the definition and the operating loop; this interview is the retrospective, and it arrives with one correction to the name itself.
”I have never built a harness”
The single most corrective line in the video, and one the wiki should propagate, because the term’s name invites exactly the wrong reading:
“I have never built a harness. I think this is a big misnomer with what I term harness engineering. I have always kept the Antigravity-like thing in your agentic system as fixed.”
Harness engineering, in the coiner’s own account, is not building a harness. It is curating tools and context around a fixed one. The prescription that follows:
“All harnesses expose essentially a file read, a grep and an arbitrary command execution tool, which means if you focus all of your efforts on improving quality on tools and context, you can freely adopt the newest models as they come out, and you’ll be constantly accruing leverage into a bit of the system that will never become obsolete.”
And the warning attached, which is the corpus’s first explicit statement of a downside to harness investment:
“You can very much over-scaffold around them, which constrains them unnecessarily as they get better and gets you into sunk cost fallacy around not wanting to throw this stuff away.”
For the boundary, this is the third Google Cloud statement in two months — July’s “everything after the LLM”, September’s “everything around the model”, and now “everything in that AI agent that isn’t the LLM.” Three phrasings, one line, with Tilde Thurium present at all three.
Loop size as the unit of progress
His account of what harness engineering is for has shifted since February from artifact-shape toward a single scalar. Agents do not cohere over long horizons by default, so:
“All of harness engineering is an increasingly sophisticated set of tricks to bring the agent back to baseline.”
The mechanism is a ladder: small PRs are easy to review → easy-to-review PRs can be reviewed by agents → agent review narrows the state space → a narrower state space supports longer horizons with less human intervention. “And this is what is meant by increasing the size of the loop that you are using agents for.” At the top of that ladder, “wholesale language migrations are tractable because you have put enough guardrails in place to know that a bunch of changes stacked end to end are good.”
He then maps the engineering ladder onto it directly, which is the most quotable framing in the episode:
“In the same way I want staff engineers solving problems for the organization six months out — I want, from junior to senior to staff engineers with agents, think about how far in advance they can unblock their agentic team.”
Seniority measured as loop size. Compare agent-fleet-management’s span-of-control framing: this is the same question asked about time rather than headcount.
Two smaller ideas worth keeping
Capability overhang. New vocabulary for the corpus, and his stated motivation for moving to deployment work: “today we have what’s called capability overhang, where the models are so good beyond what we are able to extract from them in terms of useful work today.” His job, as he frames it, is “gobbling up as much of that capability overhang” as possible. This is the same claim Garry Tan makes as “you can live in 2028 today” — the frontier is under-exploited, not under-built.
The RPG-stats account of a shared agent. Team members each contribute their specialism to one agent: “I get a new person on the team who is a React architect and boom, the attention that they pay is able to bump out the stats in front-end architecture and performance… you can get quite a well-rounded agent that has the best of everyone.” Which then forces the agent to self-route: “if you only have agents doing the work, they need to figure out which expertise they need to activate” — so the agent classifies the task, then dynamically discovers the context that classification requires. Sprint planning, internalised.
The code segment: linear vs closed loop
Billy builds three harnesses by hand, and the framing is a good one — “you can just use the framework, but a great engineer will really understand the framework. Building a harness yourself is how you understand what’s happening under the hood when things break.”
| Pattern | Shape | When |
|---|---|---|
| Linear | inspect file → output → exit; same flow every time | ”great if you need some level of determinism” |
| Closed loop | apply edit → run tests → capture the failure output, not just pass/fail → feed the error back into memory → repeat (capped, ~5 iterations) | code editing; run until resolved |
| ADK with guardrails | memory compaction built in, plus a block_destructive_commands check before execution (no rm, no dropping the database, no pushing to GitHub) | when you want customisation without writing the plumbing |
These three sit inside what the graph-engineering video called a node: a graph’s function nodes carry deterministic logic, its agent nodes carry loops of exactly this shape.
The detail worth noting is in the closed loop: “we’re going to see why it failed and feed that error back into memory”. Failure text as the loop’s actual payload — not a boolean.
And the segment’s closing line is the corpus’s thesis restated by a vendor: what makes Antigravity, Claude Code and Cursor feel good “isn’t the models themselves. Those models are really smart. It’s the harness engineering around the models.”
The three-layer stack (the product segment)
Smitha’s framing — “your coding agent doesn’t need a smarter model, it needs a better stack” — with one Google product per layer:
- Model — Gemini 3.8 Flash. The argument against reaching for the heaviest reasoning tier is agent-shaped: an agent “might inspect a directory, update a function, execute unit tests, and then repeat that sequence 20, 40, or even 60 times just to finish one task”, so “speed and cost compound dramatically” and a fast cheap model “isn’t a downgrade — it is the exact thing that makes real-time agentic loops practical.” This is small-language-models’s argument reached from the loop-count side rather than the device-fit side.
- Harness — Antigravity Boost. “Boost is a command that transforms a single model into a coordinated team”: an orchestrator that delegates specialised sub-agents in parallel and “finishes with an independent verification pass that thoroughly audits the work before anything touches your code base.” Explicitly not for everyday work — save it for “deeply intricate engineering challenges.” Note the separate-verifier design, which is the control agent-oversight-and-delegation records as never-let-the-agent-grade-its-own-homework.
- Knowledge — Google Skills. A GitHub repo, “recently crossed 19,000 stars”, 100+ skills across Google Cloud, Firebase, Flutter, Maps. “A skill is curated domain knowledge that your coding agent loads on demand… not just an MCP server, not a heavy plugin.” And it is harness-agnostic: “whether you’re running Claude Code, Codex or Google Antigravity, they can all pull from this exact repository.”
That last point is the strategically interesting one. A hyperscaler shipping its domain knowledge as a portable skills layer that works inside a competitor’s harness is a different bet from shipping a harness — and it is consistent with Lopopolo’s own argument that tools and context are the durable investment while the harness is swappable.
Dynamic capabilities (Warner & Wäger)
digital-sensing/digital-mindset-crafting— the interview’s explicit closing advice is about updating beliefs: “it’s very important to continually be updating what you think is possible with these lovely tools”, and “be actively discarding all your priors on what is possible because the world moves very quickly.”digital-seizing/rapid-prototyping— the code segment is a build-it-yourself-to-understand-it exercise, and the whole episode ships with a codelab-style pointer to Antigravity and the Skills repo.digital-transforming/improving-digital-maturity— the loop-size ladder is a maturity model: start where you trust a small change, stack changes, widen the loop, until language migrations are tractable. It presumes a working practice and describes how to grow it.
Linked entities and concepts
- Concepts: agent-harness, agentic-engineering, graph-engineering, ai-agents, agent-fleet-management, agent-oversight-and-delegation, small-language-models, agent-development-lifecycle
- Entities: Ryan Lopopolo, Tilde Thurium, Smitha Kolan, Google, Antigravity, Agent Development Kit, OpenAI, Claude Code, Cursor
- Dangling (single-source mention, deferred): Luke, Billy, The Agent Factory, Antigravity Boost, Google Skills, Gemini 3.8 Flash
- Promoted 2026-09-16: Smitha — named in full as Smitha Kolan by the July Agent Factory episode, her third appearance in the corpus.
Scope and reliability
A vendor explainer with a product round-up attached, and the last third is straightforwardly promotional (three Google products, one per layer). Zero measurements: no latency numbers, no cost comparison, no evidence that Boost’s verification pass catches anything, and the 19,000 GitHub stars is a popularity metric, not a quality one.
The interview is the part worth citing, and even there the claims are self-reported by an interested party about his own practice — “I don’t think I’ve actually opened an editor since May of last year” is unverifiable and comes from someone whose professional identity is built on it.
Transcript quality is good (human-curated CC track) but the captions are clearly machine-seeded and lightly edited — the channel’s own chapter title misspells its guest as “Ryan La Popolo”, and the corrections listed in the raw file’s notes: were all present in the “manual” track.
Debates and supersession
- The corpus’s record of Lopopolo’s employer was wrong and is now fixed. Ryan Lopopolo was carried as OpenAI/Codex; he has been at Google Cloud since roughly mid-July 2026. Both prior sources remain accurate as of their dates and are not superseded — his OpenAI-era essay and talk describe work done at OpenAI.
- The shift-left / shift-right metaphor is unstable in the coiner’s own usage. The corpus recorded “shift right, not left” from his June talk; this video argues the identical substance as shifting left, and he corrects himself mid-sentence at ~18:52. The wiki should stop treating the direction as load-bearing and carry the prescription instead: move context delivery from the prompt into tools and documentation the agent discovers for itself.
- Attribution, provisionally settled. On priority the coinage goes to Lopopolo (Feb 2026), confirmed by him on camera. The wiki’s co-coinage framing is retained for Trivedy’s independent articulation, which is a separate claim from priority.
- Over-scaffolding is a risk the corpus has not been tracking. Ninety-plus sources on agent-harness argue for building more harness; this is the first to warn that scaffolding can constrain a better model and trap you in sunk cost. Nobody has measured where that line sits.
- Open: “capability overhang” is asserted, not quantified. If models really are far ahead of deployed use, that is measurable in principle — and nothing in the corpus measures it.